C++ connectedExternalNodes函数代码示例

void
ElasticBeam2d::Print(OPS_Stream &s, int flag)
{
  // to update forces!
  this->getResistingForce();

  if (flag == -1) {
    int eleTag = this->getTag();
    s << "EL_BEAM\t" << eleTag << "\t";
    s << 0 << "\t" << 0 << "\t" << connectedExternalNodes(0) << "\t" << connectedExternalNodes(1) ;
    s << "0\t0.0000000\n";
  } else {
    this->getResistingForce();
    s << "\nElasticBeam2d: " << this->getTag() << endln;
    s << "\tConnected Nodes: " << connectedExternalNodes ;
    s << "\tCoordTransf: " << theCoordTransf->getTag() << endln;
    s << "\tmass density:  " << rho << ", cMass: " << cMass << endln;
    double P  = q(0);
    double M1 = q(1);
    double M2 = q(2);
    double L = theCoordTransf->getInitialLength();
    double V = (M1+M2)/L;
    s << "\tEnd 1 Forces (P V M): " << -P+p0[0]
      << " " << V+p0[1] << " " << M1 << endln;
    s << "\tEnd 2 Forces (P V M): " << P
      << " " << -V+p0[2] << " " << M2 << endln;
  }
}

ZeroLengthContact2D::ZeroLengthContact2D(int tag,
					 int Nd1, int Nd2,
					 double Knormal, double Ktangent,
					 double frictionRatio,  const Vector& normal )
  :Element(tag,ELE_TAG_ZeroLengthContact2D),
   connectedExternalNodes(numberNodes),
   N(2*numberNodes), T(2*numberNodes), ContactNormal(2),
   Ki(0), load(0)
{
    // ensure the connectedExternalNode ID is of correct size & set values
    if (connectedExternalNodes.Size() != 2)
      opserr << "FATAL ZeroLength::setUp - failed to create an ID of correct size\n";
    connectedExternalNodes(0) = Nd1;
    connectedExternalNodes(1) = Nd2;

	// assign Kn, Kt, fs
	Kn = Knormal;
	Kt = Ktangent;
	fs = frictionRatio;

	// assign outward contact normal of master block
 	ContactNormal(0) = normal(0)/normal.Norm();
	ContactNormal(1) = normal(1)/normal.Norm();

    // set stick point cords in LOCAL basis
	stickPt = 0;

	// initialized contact flag be zero
	ContactFlag=0;

	gap_n  = 0 ;
	lambda =0;   // add for augmented lagrange
	pressure=0;  // add for augmented lagrange
}

//  Construct element with one unidirectional material (numMaterials1d=1)
CoupledZeroLength::CoupledZeroLength(int tag,
			 int Nd1, int Nd2, 
			 UniaxialMaterial &theMat,
			 int direction1, int direction2,
			 int doRayleigh)
  :Element(tag,ELE_TAG_CoupledZeroLength),     
   connectedExternalNodes(2),
   dimension(0), numDOF(0), transformation(3,3), useRayleighDamping(doRayleigh),
   theMatrix(0), theVector(0),
   theMaterial(0), dirn1(direction1), dirn2(direction2), d0(0), v0(0)
{
  // allocate memory for numMaterials1d uniaxial material models
  theMaterial = theMat.getCopy();
  if ( theMaterial == 0) {
    opserr << "FATAL CoupledZeroLength::CoupledZeroLength - failed to create a 1d  material\n";
    exit(-1);
  }

  // initialize uniaxial materials and directions and check for valid values
  if (direction1 < 0 || direction1 > 5 || direction2 < 0 || direction2 > 5) {
    opserr << "FATAL: CoupledZeroLength::CoupledZeroLength - invalid diection\n";
    exit(-1);
  }

  connectedExternalNodes(0) = Nd1;
  connectedExternalNodes(1) = Nd2;
  dX = 0.0;
  dY = 0.0;
  fX = 0.0;
  fY = 0.0;
}

void YamamotoBiaxialHDR::Print(OPS_Stream &s, int flag)
{
  
  if (flag == 0)  {
    // print everything
    s << "Element: " << this->getTag(); 
    s << "  type: YamamotoBiaxialHDR  iNode: " << connectedExternalNodes(0);
    s << "                            jNode: " << connectedExternalNodes(1) << endln;
    
    s << "Input parameters: " << endln;
    s << "  Tp: " << tp << endln;
    s << "  DDo: " << ddo << endln;
    s << "  DDi: " << ddi << endln;
    s << "  Hr: " << hr << endln;
    s << "  Cr: " << cr << endln;
    s << "  Cs: " << cs << endln;
    
    // determine resisting forces in global system
    //s << "  resisting force: " << this->getResistingForce() << endln;
    //s << "  Disp-x: " << this->getStrain(0) << endln;
    //s << "  Force-x: " << this->getStress(0) << endln;
    //s << "  Stiff-x: " << this->getTangent(0) << endln;
    //s << "  StiffInit-x: " << this->getInitialTangent(0) << endln;
    //s << "  Disp-y: " << this->getStrain(1) << endln;
    //s << "  Force-y: " << this->getStress(1) << endln;
    //s << "  Stiff-y: " << this->getTangent(1) << endln;
    //s << "  StiffInit-y: " << this->getInitialTangent(1) << endln;

  } else if (flag == 1)  {
    // does nothing
  }
}

void
TPB1D::Print(OPS_Stream &s, int flag)
{
    // compute the strain and axial force in the member
    if (flag == 0) { // print everything
	s << "Element: " << this->getTag(); 
	s << " type: TPB1D  iNode: " << connectedExternalNodes(0);
	s << " jNode: " << connectedExternalNodes(1) << endln;
	s << " direction: " << direction << "\n";
	opserr << " mu1: " << mu[0] << endln;
	opserr << " mu2: " << mu[1]<< endln;
	opserr << " mu3: " << mu[2]<< endln;
	
	opserr << " R1: " << R[0]<< endln;
	opserr << " R2: " << R[1]<< endln;
	opserr << " R3: " << R[2]<< endln;

	opserr << " h1: " << h[0]<< endln;
	opserr << " h2: " << h[1]<< endln;
	opserr << " h3: " << h[2]<< endln;
	
	opserr << " D1: " << D[0]<< endln;
	opserr << " D2: " << D[1]<< endln;
	opserr << " D3: " << D[2]<< endln;

	opserr << " d1: " << d[0]<< endln;
	opserr << " d2: " << d[1]<< endln;
	opserr << " d3: " << d[2]<< endln;

	s << "\tMaterial: \n";
	s << *(theMaterial);
    }
}

void GenericClient::Print(OPS_Stream &s, int flag)
{
    int i;
    if (flag == OPS_PRINT_CURRENTSTATE) {
        // print everything
        s << "Element: " << this->getTag() << endln;
        s << "  type: GenericClient" << endln;
        for (i=0; i<numExternalNodes; i++ )
            s << "  Node" << i+1 << ": " << connectedExternalNodes(i);
        s << endln;
        s << "  ipAddress: " << machineInetAddr
            << ", ipPort: " << port << endln;
        s << "  addRayleigh: " << addRayleigh << endln;
        // determine resisting forces in global system
        s << "  resisting force: " << this->getResistingForce() << endln;
    }

    if (flag == OPS_PRINT_PRINTMODEL_JSON) {
        s << "\t\t\t{";
        s << "\"name\": " << this->getTag() << ", ";
        s << "\"type\": \"GenericClient\", ";
        s << "\"nodes\": [";
        for (i = 0; i < numExternalNodes - 1; i++)
            s << connectedExternalNodes(i) << ", ";
        s << connectedExternalNodes(numExternalNodes) << "], ";
        s << "\"ipAddress\": " << machineInetAddr << ", ";
        s << "\"ipPort\": " << port << ", ";
        s << "\"addRayleigh\": " << addRayleigh << "}";
    }
}

void
	Truss2::Print(OPS_Stream &s, int flag)
{
	// compute the strain and axial force in the member
	double strain, force;
	strain = theMaterial->getStrain();
	force = A * theMaterial->getStress();

	if (flag == 0) { // print everything
		s << "Element: " << this->getTag(); 
		s << " type: Truss2  iNode: " << connectedExternalNodes(0);
		s << " jNode: " << connectedExternalNodes(1);
		s << " Area: " << A << " Mass/Length: " << rho;

		s << " \n\t strain: " << strain;
		s << " axial load: " <<  force;
		if (L != 0.0) {
			int numDOF2 = numDOF/2;
			double temp;
			for (int i = 0; i < dimension; i++) {
				temp = cosX[i]*force;
				(*theVector)(i) = -temp;
				(*theVector)(i+numDOF2) = temp;
			}
			s << " \n\t unbalanced load: " << *theVector;	
		}

		s << " \t Material: " << *theMaterial;
		s << endln;
	} else if (flag == 1) {
		s << this->getTag() << "  " << strain << "  ";
		s << force << endln;
	}
}

void
TrussSection::Print(OPS_Stream &s, int flag)
{
    // compute the strain and axial force in the member
    double strain, force;
    if (L == 0.0) {
	strain = 0;
	force = 0.0;
    } else {
		strain = this->computeCurrentStrain();
        force = 0.0;

		int order = theSection->getOrder();
		const ID &code = theSection->getType();

		Vector e (order);
	
		int i;
		for (i = 0; i < order; i++) {
			if (code(i) == SECTION_RESPONSE_P)
				e(i) = strain;
		}
	
		theSection->setTrialSectionDeformation(e);
    
		const Vector &s = theSection->getStressResultant();
		for (i = 0; i < order; i++) {
			if (code(i) == SECTION_RESPONSE_P)
				force += s(i);
		}
    }
    
    double temp;
    int numDOF2 = numDOF/2;
	if (theVector != 0) {
		for (int i=0; i<dimension; i++) {
			temp = force*cosX[i];
			(*theVector)(i) = -force;
			(*theVector)(i+numDOF2) = force;
		}
	}
    
    if (flag == 0) { // print everything
	s << "Element: " << this->getTag(); 
	s << " type: TrussSection  iNode: " << connectedExternalNodes(0);
	s << " jNode: " << connectedExternalNodes(1);
	s << " Mass density/length: " << rho;
	s << " cMass: " << cMass;

	s << " \n\t strain: " << strain;
	s << " axial load: " << force;
	if (theVector != 0) 
	    s << " \n\t unbalanced load: " << *theVector;	
	s << " \t Section: " << *theSection;
	s << endln;
    } else if (flag == 1) {
	s << this->getTag() << "  " << strain << "  ";
	s << force << endln;
    }
}

// constructor:
//  responsible for allocating the necessary space needed by each object
//  and storing the tags of the truss end nodes.
PY_Macro2D::PY_Macro2D(int tag,
		   int node1,
		   int node2,
		   double _K,
		   double _py,
		   double _a,
		   double _b,
		   double _g,
		   double _m1,
		   double _m2,
		   double _w1,
		   double _p1,
		   double _S1,
		   double _beta,
		   double _s1,
		   double _tolerance,
		   int _maxNumIter)
 :Element(tag, ELE_TAG_PY_MACRO2D),
  K(_K), py(_py), a(_a), b(_b), g(_g), m1(_m1), m2(_m2),
  w1(_w1), p1(_p1), S1(_S1), beta(_beta), s1(_s1), 
  tolerance(_tolerance), maxNumIter(_maxNumIter),
  Ttangent(0.0), Tforce(0.0), Tz(0.0), TU(0.0), TW(0.0), TS(1.0), TS0(1.0), CW(0.0), CS(1.0), CS0(1.0), 
  Ctangent(0.0), Cforce(0.0), Cz(0.0), CU(0.0), Tt(0.0), Ct(0.0), trans(1,4),
  connectedExternalNodes(2)
{
  connectedExternalNodes(0) = node1;
  connectedExternalNodes(1) = node2;

  // set node pointers to NULL
  for (int i=0; i<2; i++)
    theNodes[i] = 0;
}

// constructor:
//  responsible for allocating the necessary space needed by each object
//  and storing the tags of the CorotTruss end nodes.
CorotTruss::CorotTruss(int tag, int dim,
			   int Nd1, int Nd2, 
			   UniaxialMaterial &theMat,
			   double a, double r)
  :Element(tag,ELE_TAG_CorotTruss),     
  theMaterial(0), connectedExternalNodes(2),
  numDOF(0), numDIM(dim),
  Lo(0.0), Ln(0.0), 
  A(a), rho(r), R(3,3),
  theMatrix(0), theVector(0)
{
  // get a copy of the material and check we obtained a valid copy
  theMaterial = theMat.getCopy();
  if (theMaterial == 0) {
    opserr << "FATAL CorotTruss::CorotTruss - " <<  tag <<
      "failed to get a copy of material with tag " << theMat.getTag() << endln;
    exit(-1);
  }
  
  // ensure the connectedExternalNode ID is of correct size & set values
  if (connectedExternalNodes.Size() != 2) {
    opserr << "FATAL CorotTruss::CorotTruss - " <<  tag <<
      "failed to create an ID of size 2\n";
    exit(-1);
  }
  
  connectedExternalNodes(0) = Nd1;
  connectedExternalNodes(1) = Nd2;        

  // set node pointers to NULL
  theNodes[0] = 0;
  theNodes[1] = 0;
}

void
PY_Macro2D::Print(OPS_Stream &s, int flag)
{
  s << "Element: " << this->getTag();
  s << " type: PY_Macro2D  iNode: " << connectedExternalNodes(0);
  s << " jNode: " << connectedExternalNodes(1) << endln;
}

int
ElasticBeam3d::recvSelf(int cTag, Channel &theChannel, FEM_ObjectBroker &theBroker)
{
  int res = 0;
  static Vector data(17);

  res += theChannel.recvVector(this->getDbTag(), cTag, data);
  if (res < 0) {
    opserr << "ElasticBeam3d::recvSelf -- could not receive data Vector\n";
    return res;
  }
  
  A = data(0);
  E = data(1); 
  G = data(2); 
  Jx = data(3); 
  Iy = data(4); 
  Iz = data(5);     
  rho = data(6);
  cMass = (int)data(7);
  this->setTag((int)data(8));
  connectedExternalNodes(0) = (int)data(9);
  connectedExternalNodes(1) = (int)data(10);
  
  alphaM = data(13);
  betaK = data(14);
  betaK0 = data(15);
  betaKc = data(16);
  
  // Check if the CoordTransf is null; if so, get a new one
  int crdTag = (int)data(11);
  if (theCoordTransf == 0) {
    theCoordTransf = theBroker.getNewCrdTransf(crdTag);
    if (theCoordTransf == 0) {
      opserr << "ElasticBeam3d::recvSelf -- could not get a CrdTransf3d\n";
      exit(-1);
    }
  }
  
  // Check that the CoordTransf is of the right type; if not, delete
  // the current one and get a new one of the right type
  if (theCoordTransf->getClassTag() != crdTag) {
    delete theCoordTransf;
    theCoordTransf = theBroker.getNewCrdTransf(crdTag);
    if (theCoordTransf == 0) {
      opserr << "ElasticBeam3d::recvSelf -- could not get a CrdTransf3d\n";
      exit(-1);
    }
  }
  
  // Now, receive the CoordTransf
  theCoordTransf->setDbTag((int)data(12));
  res += theCoordTransf->recvSelf(cTag, theChannel, theBroker);
  if (res < 0) {
    opserr << "ElasticBeam3d::recvSelf -- could not receive CoordTransf\n";
    return res;
  }
  
  return res;
}

// constructor:
//  responsible for allocating the necessary space needed by each object
//  and storing the tags of the CorotTrussSection end nodes.
CorotTrussSection::CorotTrussSection(int tag, int dim,
			   int Nd1, int Nd2, 
			   SectionForceDeformation &theSec,
			   double r, int damp, int cm)
  :Element(tag,ELE_TAG_CorotTrussSection),     
  theSection(0), connectedExternalNodes(2),
  numDOF(0), numDIM(dim), Lo(0.0), Ln(0.0),
  rho(r), doRayleighDamping(damp), cMass(cm),
  R(3,3), theLoad(0), theMatrix(0), theVector(0)
{
  // get a copy of the material and check we obtained a valid copy
  theSection = theSec.getCopy();
  if (theSection == 0) {
    opserr << "FATAL CorotTrussSection::CorotTrussSection - " << tag << 
      "failed to get a copy of material with tag " << theSec.getTag() << endln;
    exit(-1);
  }
  
  // ensure the connectedExternalNode ID is of correct size & set values
  if (connectedExternalNodes.Size() != 2) {
    opserr << "FATAL CorotTrussSection::CorotTrussSection - " <<  tag <<
      "failed to create an ID of size 2\n";
    exit(-1);
  }
  
  connectedExternalNodes(0) = Nd1;
  connectedExternalNodes(1) = Nd2;        

  // set node pointers to NULL
  for (int i=0; i<2; i++)
    theNodes[i] = 0;
}

ElasticBeam3d::ElasticBeam3d(int tag, double a, double e, double g, 
			     double jx, double iy, double iz, int Nd1, int Nd2, 
			     CrdTransf &coordTransf, double r, int cm, int sectTag)
  :Element(tag,ELE_TAG_ElasticBeam3d), 
  A(a), E(e), G(g), Jx(jx), Iy(iy), Iz(iz), rho(r), cMass(cm), sectionTag(sectTag),
  Q(12), q(6), connectedExternalNodes(2), theCoordTransf(0)
{
  connectedExternalNodes(0) = Nd1;
  connectedExternalNodes(1) = Nd2;
  
  theCoordTransf = coordTransf.getCopy3d();
  
  if (!theCoordTransf) {
    opserr << "ElasticBeam3d::ElasticBeam3d -- failed to get copy of coordinate transformation\n";
    exit(-1);
  }

  q0[0] = 0.0;
  q0[1] = 0.0;
  q0[2] = 0.0;
  q0[3] = 0.0;
  q0[4] = 0.0;

  p0[0] = 0.0;
  p0[1] = 0.0;
  p0[2] = 0.0;
  p0[3] = 0.0;
  p0[4] = 0.0;

  // set node pointers to NULL
  for (int i=0; i<2; i++)
    theNodes[i] = 0;      
}

// responsible for allocating the necessary space needed
// by each object and storing the tags of the end nodes.
EETrussCorot::EETrussCorot(int tag, int dim, int Nd1, int Nd2,
    ExperimentalSite *site, bool iM, int addRay, double r)
    : ExperimentalElement(tag, ELE_TAG_EETrussCorot, site),
    numDIM(dim), numDOF(0), connectedExternalNodes(2),
    iMod(iM), addRayleigh(addRay), rho(r), L(0.0), Ln(0.0), R(3,3),
    theMatrix(0), theVector(0), theLoad(0),
    db(0), vb(0), ab(0), t(0),
    dbDaq(0), vbDaq(0), abDaq(0), qDaq(0), tDaq(0),
    dbCtrl(1), vbCtrl(1), abCtrl(1),
    kbInit(1,1), tLast(0.0), firstWarning(true)
{
    // ensure the connectedExternalNode ID is of correct size & set values
    if (connectedExternalNodes.Size() != 2)  {
        opserr << "EETrussCorot::EETrussCorot() - element: "
            <<  tag << " failed to create an ID of size 2\n";
        exit(-1);
    }
    
    connectedExternalNodes(0) = Nd1;
    connectedExternalNodes(1) = Nd2;
    
    // set node pointers to NULL
    theNodes[0] = 0;
    theNodes[1] = 0;
    
    // set the data size for the experimental site
    sizeCtrl = new ID(OF_Resp_All);
    sizeDaq = new ID(OF_Resp_All);
    
    (*sizeCtrl)[OF_Resp_Disp]  = 1;
    (*sizeCtrl)[OF_Resp_Vel]   = 1;
    (*sizeCtrl)[OF_Resp_Accel] = 1;
    (*sizeCtrl)[OF_Resp_Time]  = 1;
    
    (*sizeDaq)[OF_Resp_Disp]   = 1;
    (*sizeDaq)[OF_Resp_Vel]    = 1;
    (*sizeDaq)[OF_Resp_Accel]  = 1;
    (*sizeDaq)[OF_Resp_Force]  = 1;
    (*sizeDaq)[OF_Resp_Time]   = 1;
    
    theSite->setSize(*sizeCtrl, *sizeDaq);
    
    // allocate memory for trial response vectors
    db = new Vector(1);
    vb = new Vector(1);
    ab = new Vector(1);
    t  = new Vector(1);
    
    // allocate memory for daq response vectors
    dbDaq = new Vector(1);
    vbDaq = new Vector(1);
    abDaq = new Vector(1);
    qDaq  = new Vector(1);
    tDaq  = new Vector(1);
    
    // initialize additional vectors
    dbCtrl.Zero();
    vbCtrl.Zero();
    abCtrl.Zero();
}