C++ Domain::addElement方法代码示例

int OPS_PFEMElement2D(Domain& theDomain, const ID& elenodes, ID& eletags)
{
    int numdata = OPS_GetNumRemainingInputArgs();
    if(numdata < 4) {
	opserr<<"WARNING: insufficient number of arguments\n";
	return 0;
    }

    // rho, mu, b1, b2, (thickness, kappa, lumped)
    numdata = OPS_GetNumRemainingInputArgs();
    if(numdata > 7) numdata = 7;
    double data[7] = {0,0,0,0,1.0,-1,1};
    if(OPS_GetDoubleInput(&numdata,data) < 0) return 0;

    // create elements
    ElementIter& theEles = theDomain.getElements();
    Element* theEle = theEles();
    int currTag = 0;
    if (theEle != 0) {
	currTag = theEle->getTag();
    }

    eletags.resize(elenodes.Size()/3);

    for (int i=0; i<eletags.Size(); i++) {
	theEle = new PFEMElement2D(--currTag,elenodes(3*i),elenodes(3*i+1),elenodes(3*i+2),
				   data[0],data[1],data[2],data[3],data[4],data[5],data[6]);
	if (theEle == 0) {
	    opserr<<"WARNING: run out of memory for creating element\n";
	    return -1;
	}
	if (theDomain.addElement(theEle) == false) {
	    opserr<<"WARNING: failed to add element to domain\n";
	    delete theEle;
	    return -1;
	}
	eletags(i) = currTag;
    }

    return 0;
}

int
Mesh::newElements(const ID& elends)
{
    Domain* domain = OPS_GetDomain();
    if (domain == 0) {
        opserr << "WARNING: domain is not created\n";
        return -1;
    }

    // if no element, no new elements
    if (eleType == 0) return 0;
    if (elends.Size() < numelenodes) {
        return 0;
    }

    // function to call
    void* (*OPS_Func)(const ID& info) = 0;
    switch (eleType) {
    case ELE_TAG_ElasticBeam2d:
        OPS_Func = OPS_ElasticBeam2d;
        break;
    case ELE_TAG_ForceBeamColumn2d:
        OPS_Func = OPS_ForceBeamColumn2d;
        break;
    case ELE_TAG_DispBeamColumn2d:
        OPS_Func = OPS_DispBeamColumn2d;
        break;
    case ELE_TAG_PFEMElement2DBubble:
        OPS_Func = OPS_PFEMElement2DBubble;
        break;
    case ELE_TAG_PFEMElement3DBubble:
        OPS_Func = OPS_PFEMElement3DBubble;
        break;
    case ELE_TAG_PFEMElement2Dmini:
        OPS_Func = OPS_PFEMElement2Dmini;
        break;
    case ELE_TAG_PFEMElement2DCompressible:
        OPS_Func = OPS_PFEMElement2DCompressible;
        break;
    case ELE_TAG_Tri31:
        OPS_Func = OPS_Tri31;
        break;
    case ELE_TAG_FourNodeTetrahedron:
	OPS_Func = OPS_FourNodeTetrahedron;
	break;
    case ELE_TAG_ShellMITC4:
	OPS_Func = OPS_ShellMITC4;
	break;
    default:
        OPS_Func = OPS_ElasticBeam2d;
    }



    int eletag = this->nextEleTag();
    int nodetag = this->nextNodeTag();

    // create elements
    ID neweletags(elends.Size()/numelenodes);
    std::vector<Element*> neweles(neweletags.Size());

#pragma omp parallel for
    for (int i=0; i<neweletags.Size(); ++i) {

	// element tag
	neweletags(i) = eletag+i;

	// info
	ID info(numelenodes+4);
	info(0) = 2; // load data
	info(1) = this->getTag(); // mesh tag
        info(2) = neweletags(i); // ele tag
        for (int j=0; j<numelenodes; ++j) {
	    // get elenode
            info(3+j) = elends(numelenodes*i+j);
        }
	info(numelenodes+3) = nodetag+i;

	// create element
        neweles[i] = (Element*)OPS_Func(info);
    }

    // add elements to domain
    for (unsigned int i=0; i<neweles.size(); ++i) {
    	if (neweles[i] == 0) {
            opserr<<"WARING: run out of memory for creating element\n";
            return -1;
        }
        if (domain->addElement(neweles[i]) == false) {
            opserr<<"WARNING: failed to add element to domain\n";
            delete neweles[i];
            return -1;
        }
    }

    this->addEleTags(neweletags);

    return 0;
}

// main routine
int main(int argc, char **argv)
{
    //
    //	now create a domain and a modelbuilder
    //  and build the model
    //

    Domain *theDomain = new Domain();
    
    // create the nodes using constructor: 
    //		Node(tag, ndof, crd1, crd2)
    // and then add them to the domain
    
    Node *node1 = new Node(1, 2,   0.0,  0.0);
    Node *node2 = new Node(2, 2, 144.0,  0.0);
    Node *node3 = new Node(3, 2, 168.0,  0.0);    
    Node *node4 = new Node(4, 2,  72.0, 96.0);        
    theDomain->addNode(node1);
    theDomain->addNode(node2);
    theDomain->addNode(node3);
    theDomain->addNode(node4);
    
    // create an elastic material using constriuctor:  
    //		ElasticMaterialModel(tag, E)

    UniaxialMaterial *theMaterial = new ElasticMaterial(1, 3000);
    
    // create the truss elements using constructor:
    //		Truss(tag, dim, nd1, nd2, Material &,A)
    // and then add them to the domain
    
    Truss *truss1 = new Truss(1, 2, 1, 4, *theMaterial, 10.0);
    Truss *truss2 = new Truss(2, 2, 2, 4, *theMaterial,  5.0);    
    Truss *truss3 = new Truss(3, 2, 3, 4, *theMaterial,  5.0);        
    theDomain->addElement(truss1);
    theDomain->addElement(truss2);
    theDomain->addElement(truss3);    
    
    // create the single-point constraint objects using constructor:
    //		SP_Constraint(tag, nodeTag, dofID, value)
    // and then add them to the domain
    
    SP_Constraint *sp1 = new SP_Constraint(1, 1, 0, 0.0);
    SP_Constraint *sp2 = new SP_Constraint(2, 1, 1, 0.0);    
    SP_Constraint *sp3 = new SP_Constraint(3, 2, 0, 0.0);
    SP_Constraint *sp4 = new SP_Constraint(4, 2, 1, 0.0);    
    SP_Constraint *sp5 = new SP_Constraint(5, 3, 0, 0.0);
    SP_Constraint *sp6 = new SP_Constraint(6, 3, 1, 0.0);        
    theDomain->addSP_Constraint(sp1);
    theDomain->addSP_Constraint(sp2);
    theDomain->addSP_Constraint(sp3);
    theDomain->addSP_Constraint(sp4);    
    theDomain->addSP_Constraint(sp5);    
    theDomain->addSP_Constraint(sp6);    

    // construct a linear time series object using constructor:
    //		LinearSeries()
    
    TimeSeries *theSeries = new LinearSeries();
    
    // construct a load pattren using constructor:
    //		LoadPattern(tag)
    // and then set it's TimeSeries and add it to the domain
    
    LoadPattern *theLoadPattern = new LoadPattern(1);
    theLoadPattern->setTimeSeries(theSeries);
    theDomain->addLoadPattern(theLoadPattern);
    
    // construct a nodal load using constructor:
    //		NodalLoad(tag, nodeID, Vector &)
    // first construct a Vector of size 2 and set the values NOTE C INDEXING
    // then construct the load and add it to the domain
    
    Vector theLoadValues(2);
    theLoadValues(0) = 100.0;
    theLoadValues(1) = -50.0;
    NodalLoad *theLoad = new NodalLoad(1, 4, theLoadValues);
    theDomain->addNodalLoad(theLoad, 1);

    // create an Analysis object to perform a static analysis of the model
    //  - constructs:
    //    AnalysisModel of type AnalysisModel,
    //	  EquiSolnAlgo of type Linear
    //	  StaticIntegrator of type LoadControl
    //	  ConstraintHandler of type Penalty
    //    DOF_Numberer which uses RCM
    //    LinearSOE of type Band SPD
    // and then the StaticAnalysis object
    
    AnalysisModel     *theModel = new AnalysisModel();
    EquiSolnAlgo      *theSolnAlgo = new Linear();
    StaticIntegrator  *theIntegrator = new LoadControl(1.0, 1, 1.0, 1.0);
    ConstraintHandler *theHandler = new PenaltyConstraintHandler(1.0e8,1.0e8);
    RCM               *theRCM = new RCM();
    DOF_Numberer      *theNumberer = new DOF_Numberer(*theRCM);    
    BandSPDLinSolver  *theSolver = new BandSPDLinLapackSolver();       
    LinearSOE         *theSOE = new BandSPDLinSOE(*theSolver);        

    StaticAnalysis    theAnalysis(*theDomain,
//.........这里部分代码省略.........

int OPS_ElasticBeam2d(Domain& theDomain, const ID& elenodes, ID& eletags)
{
    if(OPS_GetNumRemainingInputArgs() < 4) {
	opserr<<"insufficient arguments:A,E,Iz,transfTag\n";
	return -1;
    }

    // inputs: 
    double data[3];
    int numData = 3;
    if(OPS_GetDoubleInput(&numData,&data[0]) < 0) return -1;

    numData = 1;
    int transfTag;
    if(OPS_GetIntInput(&numData,&transfTag) < 0) return -1;
    
    // options
    double mass = 0.0, alpha=0.0, depth=0.0;
    int cMass = 0;
    while(OPS_GetNumRemainingInputArgs() > 0) {
	std::string type = OPS_GetString();
	if(type == "-alpha") {
	    if(OPS_GetNumRemainingInputArgs() > 0) {
		if(OPS_GetDoubleInput(&numData,&alpha) < 0) return -1;
	    }
	} else if(type == "-depth") {
	    if(OPS_GetNumRemainingInputArgs() > 0) {
		if(OPS_GetDoubleInput(&numData,&depth) < 0) return -1;
	    }

	} else if(type == "-mass") {
	    if(OPS_GetNumRemainingInputArgs() > 0) {
		if(OPS_GetDoubleInput(&numData,&mass) < 0) return -1;
	    }
	} else if(type == "-cMass") {
	    cMass = 1;
	}
    }

    // check transf
    CrdTransf* theTransf = OPS_getCrdTransf(transfTag);
    if(theTransf == 0) {
	opserr<<"coord transfomration not found\n";
	return -1;
    }

    // create elements
    ElementIter& theEles = theDomain.getElements();
    Element* theEle = theEles();
    int currTag = 0;
    if (theEle != 0) {
	currTag = theEle->getTag();
    }
    eletags.resize(elenodes.Size()/2);
    for (int i=0; i<elenodes.Size()/2; i++) {
	theEle = new ElasticBeam2d(--currTag,data[0],data[1],data[2],elenodes(2*i),elenodes(2*i+1),
				   *theTransf,alpha,depth,mass,cMass);
	if (theEle == 0) {
	    opserr<<"WARING: run out of memory for creating element\n";
	    return -1;
	}
	if (theDomain.addElement(theEle) == false) {
	    opserr<<"WARNING: failed to add element to domain\n";
	    delete theEle;
	    return -1;
	}
	eletags(i) = currTag;
    }

    return 0;
}

int main(int argc, char **argv)
{
    //  first build our error handler
    g3ErrorHandler = new ConsoleErrorHandler();

    //
    //	now create a domain and a modelbuilder
    //  and build the model
    //

    //  Domain *theDomain = new Domain();

    MapOfTaggedObjects theStorage;
    //  ArrayOfTaggedObjects theStorage(32);    
    Domain *theDomain = new Domain(theStorage);
    
    // create the nodes using constructor: 
    //		Node(tag, ndof, crd1, crd2, crd3 )
    // and then add them to the domain
    
    Node *node1 = new Node(1, 3, 1.0, 1.0, 0.0 );
    Node *node2 = new Node(2, 3, 0.0, 1.0, 0.0 );
    Node *node3 = new Node(3, 3, 0.0, 0.0, 0.0 );    
    Node *node4 = new Node(4, 3, 1.0, 0.0, 0.0 );        
    Node *node5 = new Node(5, 3, 1.0, 1.0, 1.0 );
    Node *node6 = new Node(6, 3, 0.0, 1.0, 1.0 );
    Node *node7 = new Node(7, 3, 0.0, 0.0, 1.0 );    
    Node *node8 = new Node(8, 3, 1.0, 0.0, 1.0 );        
   
    theDomain->addNode(node1);
    theDomain->addNode(node2);
    theDomain->addNode(node3);
    theDomain->addNode(node4);
    theDomain->addNode(node5);
    theDomain->addNode(node6);
    theDomain->addNode(node7);
    theDomain->addNode(node8);
    
    // create an elastic isotropic 3D material using constriuctor:  
    //		ElasticIsotropic3D(tag, E, v)

    NDMaterial *theMaterial = new ElasticIsotropic3D(1, 3000, 0.3);
    
    // create the EightNodeBrick elements using constructor:
    //		EightNodeBrick(tag, nd1, nd2, nd3, nd4, nd5, nd6, nd7, nd8, 
    //                           Material &, const *char type, double bodyforce1, double bodyforce2,
    //			         double pressure, double rho, EPState *InitEPS)
    // and then add them to the domain
        
    // For elastic material, no EPState, just supply null.
    EPState *eps = 0; 
    EightNodeBrick *brick = new EightNodeBrick(1, 5, 6, 7, 8, 1, 2, 3, 4,
                              theMaterial, "ElasticIsotropic3D", 
			      0.0, 0.0, 0.0, 1.8, eps);        
    
    theDomain->addElement( brick );    
    
    // create the single-point constraint objects using constructor:
    //		SP_Constraint(tag, nodeTag, dofID, value)
    // and then add them to the domain
    
    SP_Constraint *sp1  = new SP_Constraint(1,  1, 0, 0.0);
    SP_Constraint *sp2  = new SP_Constraint(2,  1, 1, 0.0);    
    SP_Constraint *sp3  = new SP_Constraint(3,  1, 2, 0.0);
    SP_Constraint *sp4  = new SP_Constraint(4,  2, 0, 0.0);    
    SP_Constraint *sp5  = new SP_Constraint(5,  2, 1, 0.0);
    SP_Constraint *sp6  = new SP_Constraint(6,  2, 2, 0.0);        
    SP_Constraint *sp7  = new SP_Constraint(7,  3, 0, 0.0);
    SP_Constraint *sp8  = new SP_Constraint(8,  3, 1, 0.0);    
    SP_Constraint *sp9  = new SP_Constraint(9,  3, 2, 0.0);
    SP_Constraint *sp10 = new SP_Constraint(10, 4, 0, 0.0);    
    SP_Constraint *sp11 = new SP_Constraint(11, 4, 1, 0.0);
    SP_Constraint *sp12 = new SP_Constraint(12, 4, 2, 0.0);        

    theDomain->addSP_Constraint(sp1 );
    theDomain->addSP_Constraint(sp2 );
    theDomain->addSP_Constraint(sp3 );
    theDomain->addSP_Constraint(sp4 );    
    theDomain->addSP_Constraint(sp5 );    
    theDomain->addSP_Constraint(sp6 );    
    theDomain->addSP_Constraint(sp7 );
    theDomain->addSP_Constraint(sp8 );
    theDomain->addSP_Constraint(sp9 );
    theDomain->addSP_Constraint(sp10);    
    theDomain->addSP_Constraint(sp11);    
    theDomain->addSP_Constraint(sp12);    

    // construct a linear time series object using constructor:
    //		LinearSeries()
    
    TimeSeries *theSeries = new LinearSeries();
    
    // construct a load pattren using constructor:
    //		LoadPattern(tag)
    // and then set it's TimeSeries and add it to the domain
    
    LoadPattern *theLoadPattern = new LoadPattern(1);
    theLoadPattern->setTimeSeries(theSeries);
    theDomain->addLoadPattern(theLoadPattern);
    
//.........这里部分代码省略.........

int main(int argc, char **argv)
{
    //  first build our error handler
    g3ErrorHandler = new ConsoleErrorHandler();

    //
    //	now create a domain and a modelbuilder
    //  and build the model
    //

//    Domain *theDomain = new Domain();

    MapOfTaggedObjects theStorage;
//    ArrayOfTaggedObjects theStorage(32);
    Domain *theDomain = new Domain(theStorage);

    // create the nodes using constructor:
    //		Node(tag, ndof, crd1, crd2)
    // and then add them to the domain

    Node *node1 = new Node(1, 3, 1.0, 1.0, 0.0 );
    Node *node2 = new Node(2, 3, 0.0, 1.0, 0.0 );
    Node *node3 = new Node(3, 3, 0.0, 0.0, 0.0 );
    Node *node4 = new Node(4, 3, 1.0, 0.0, 0.0 );
    Node *node5 = new Node(5, 3, 1.0, 1.0, 1.0 );
    Node *node6 = new Node(6, 3, 0.0, 1.0, 1.0 );
    Node *node7 = new Node(7, 3, 0.0, 0.0, 1.0 );
    Node *node8 = new Node(8, 3, 1.0, 0.0, 1.0 );

    theDomain->addNode(node1);
    theDomain->addNode(node2);
    theDomain->addNode(node3);
    theDomain->addNode(node4);
    theDomain->addNode(node5);
    theDomain->addNode(node6);
    theDomain->addNode(node7);
    theDomain->addNode(node8);

    // create an elastic material using constriuctor:
    //		ElasticMaterialModel(tag, E)

    //UniaxialMaterial *theMaterial = new ElasticMaterial(1, 3000);

    double PIo3 = PI/3.0;
    PIo3 = 0.0;

    //Drucker-Prager Model
    DPYieldSurface DP_YS;
    DPPotentialSurface DP_PS(0.05);
    //EvolutionLaw_NL_Eeq DP_ELS1;
    EvolutionLaw_L_Eeq DP_ELS1(10.0);
    EvolutionLaw_T DP_ELT;
    double scalars[] = {0.3, 0.0};  //alfa1, k
    double NOS = 2; //Number of scalar vars
    double NOT = 1; //Number of tensorial vars

    stresstensor startstress;
    straintensor startstrain, otherstrain;
    startstrain = startstrain.pqtheta2strain( 0.000, 0.0000, 0.0);
    otherstrain = otherstrain.pqtheta2strain( 0.000, 0.0000, 0.0);

    stresstensor *tensors = new stresstensor[1];

    EPState EPS(3000.0, 3000.0, 0.3, 0.0, startstress, otherstrain,
                otherstrain, otherstrain, NOS, scalars, NOT, tensors);

    Template3Dep MP(1, &DP_YS, &DP_PS, &EPS, &DP_ELS1, &DP_ELT);

    NDMaterial *theMaterial = ∓
    //NDMaterial *theMaterial = new ElasticIsotropic3D(1, 3000, 0.3);

    // create the truss elements using constructor:
    //		Truss(tag, dim, nd1, nd2, Material &,A)
    // and then add them to the domain

    //Truss *truss1 = new Truss(1, 2, 1, 4, *theMaterial, 10.0);
    //Truss *truss2 = new Truss(2, 2, 2, 4, *theMaterial,  5.0);

    //EPState *eps = 0;

    EightNodeBrick *brick = new EightNodeBrick(1, 5, 6, 7, 8, 1, 2, 3, 4,
            theMaterial, "Template3Dep",
            0.0, 0.0, 0.0, 1.8, &EPS);

    //theDomain->addElement(truss1);
    //theDomain->addElement(truss2);
    theDomain->addElement( brick );

    // create the single-point constraint objects using constructor:
    //		SP_Constraint(tag, nodeTag, dofID, value)
    // and then add them to the domain

    SP_Constraint *sp1  = new SP_Constraint(1,  1, 0,  0.0259999);
    SP_Constraint *sp2  = new SP_Constraint(2,  1, 1,  0.0259999);
    SP_Constraint *sp3  = new SP_Constraint(3,  1, 2, -0.1213350);
    SP_Constraint *sp4  = new SP_Constraint(4,  2, 0, -0.0259999);
    SP_Constraint *sp5  = new SP_Constraint(5,  2, 1,  0.0259999);
    SP_Constraint *sp6  = new SP_Constraint(6,  2, 2, -0.1213350);
    SP_Constraint *sp7  = new SP_Constraint(7,  3, 0, -0.0259999);
    SP_Constraint *sp8  = new SP_Constraint(8,  3, 1, -0.0259999);
//.........这里部分代码省略.........

int OPS_Tri31(Domain& theDomain, const ID& elenodes, ID& eletags)
{
    // get inputs
    int numRemainingInputArgs = OPS_GetNumRemainingInputArgs();
    if (numRemainingInputArgs < 3) {
	opserr << "Invalid #args, want: thk? type? matTag? <pressure? rho? b1? b2?>\n";
	return -1;
    }

    int matID;
    double thk;
    char *theType;
    double dData[4];
    dData[0] = 0.0;
    dData[1] = 0.0;
    dData[2] = 0.0;
    dData[3] = 0.0;
 
    int numData = 1;
    if (OPS_GetDoubleInput(&numData, &thk) != 0) {
	opserr << "WARNING invalid thickness data: element Tri31 \n";
	return -1;
    }

    theType = (char*)OPS_GetString();
  
    numData = 1;
    if (OPS_GetIntInput(&numData, &matID) != 0) {
	opserr << "WARNING invalid integer data: element Tri31\n";
	return -1;
    }
  
    NDMaterial *theMaterial = OPS_getNDMaterial(matID);
    if (theMaterial == 0) {
	opserr << "WARNING element Tri31 \n";
	opserr << " Material: " << matID << "not found\n";
	return -1;
    }
  
    if (OPS_GetNumRemainingInputArgs() >= 4) {
	numData = 4;
	if (OPS_GetDoubleInput(&numData, &dData[0]) != 0) {
	    opserr << "WARNING invalid optional data: element Tri31\n";
	    return -1;
	}
    }

    // create elements
    ElementIter& theEles = theDomain.getElements();
    Element* theEle = theEles();
    int currTag = 0;
    if (theEle != 0) {
	currTag = theEle->getTag();
    }

    eletags.resize(elenodes.Size()/3);

    for (int i=0; i<eletags.Size(); i++) {
	theEle = new Tri31(--currTag,elenodes(3*i),elenodes(3*i+1),elenodes(3*i+2),
			   *theMaterial, theType, thk,
			   dData[0], dData[1], dData[2], dData[3]);
	if (theEle == 0) {
	    opserr<<"WARNING: run out of memory for creating element\n";
	    return -1;
	}
	if (theDomain.addElement(theEle) == false) {
	    opserr<<"WARNING: failed to add element to domain\n";
	    delete theEle;
	    return -1;
	}
	eletags(i) = currTag;
    }
  
    return 0;
}