mObject elementsToJSON(void) {
ElementIter &theEles = theDomain.getElements();
Element *theEle;
mObject eles;
mValue tag, ele;
char tag_str[15];
eles.clear();
while ((theEle = theEles()) != 0) {
tag = theEle->getTag();
ele = theEle->toJSON();
sprintf(tag_str, "%d", tag.get_int());
eles[tag_str] = ele;
}
return eles;
};
int
Mesh::nextEleTag()
{
Domain* domain = OPS_GetDomain();
if (domain == 0) {
opserr << "WARNING: domain is not created\n";
return -1;
}
ElementIter& eles = domain->getElements();
Element* ele = 0;
int etag = 0;
while((ele = eles()) != 0) {
etag = ele->getTag();
}
return etag+1;
}
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;
}
//! @brief Handle the constraints.
//!
//! Determines the number of FE\_Elements and DOF\_Groups needed from the
//! Domain (a one to one mapping between Elements and FE\_Elements and
//! Nodes and DOF\_Groups) Creates two arrays of pointers to store the
//! FE\_elements and DOF\_Groups, returning a warning message and a \f$-2\f$
//! or \f$-3\f$ if not enough memory is available for these arrays. Then the
//! object will iterate through the Nodes of the Domain, creating a
//! DOF\_Group for each node and setting the initial id for each dof to
//! \f$-2\f$ if no SFreedom\_Constraint exists for the dof, or \f$-1\f$ if a
//! SFreedom\_Constraint exists or \f$-3\f$ if the node identifier is in {\em
//! nodesToBeNumberedLast}. The object then iterates through the Elements
//! of the Domain creating a FE\_Element for each Element, if the Element
//! is a Subdomain setFE\_ElementPtr() is invoked on the Subdomain
//! with the new FE\_Element as the argument. If not enough memory is
//! available for any DOF\_Group or FE\_element a warning message is
//! printed and a \f$-4\f$ or \f$-5\f$ is returned. If any MFreedom\_Constraint
//! objects exist in the Domain a warning message is printed and \f$-6\f$ is
//! returned. If all is successful, the method returns the number of
//! degrees-of-freedom associated with the DOF\_Groups in {\em
//! nodesToBeNumberedLast}.
int XC::PlainHandler::handle(const ID *nodesLast)
{
// first check links exist to a Domain and an AnalysisModel object
Domain *theDomain = this->getDomainPtr();
AnalysisModel *theModel = this->getAnalysisModelPtr();
Integrator *theIntegrator = this->getIntegratorPtr();
if((!theDomain) || (!theModel) || (!theIntegrator))
{
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; domain, model or integrator was not set.\n";
return -1;
}
// initialse the DOF_Groups and add them to the AnalysisModel.
// : must of course set the initial IDs
NodeIter &theNod= theDomain->getNodes();
Node *nodPtr= nullptr;
SFreedom_Constraint *spPtr= nullptr;
DOF_Group *dofPtr= nullptr;
int numDOF = 0;
int count3 = 0;
int countDOF =0;
while((nodPtr = theNod()) != nullptr)
{
dofPtr= theModel->createDOF_Group(numDOF++, nodPtr);
// initially set all the ID value to -2
countDOF+= dofPtr->inicID(-2);
// loop through the SFreedom_Constraints to see if any of the
// DOFs are constrained, if so set initial XC::ID value to -1
int nodeID = nodPtr->getTag();
SFreedom_ConstraintIter &theSPs = theDomain->getConstraints().getDomainAndLoadPatternSPs();
while((spPtr = theSPs()) != 0)
if(spPtr->getNodeTag() == nodeID)
{
if(spPtr->isHomogeneous() == false)
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; non-homogeneos constraint"
<< " for node " << spPtr->getNodeTag()
<< " h**o assumed\n";
const ID &id = dofPtr->getID();
int dof = spPtr->getDOF_Number();
if(id(dof) == -2)
{
dofPtr->setID(spPtr->getDOF_Number(),-1);
countDOF--;
}
else
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; multiple single pointconstraints at DOF "
<< dof << " for node " << spPtr->getNodeTag()
<< std::endl;
}
// loop through the MFreedom_Constraints to see if any of the
// DOFs are constrained, note constraint matrix must be diagonal
// with 1's on the diagonal
MFreedom_ConstraintIter &theMPs = theDomain->getConstraints().getMPs();
MFreedom_Constraint *mpPtr;
while((mpPtr = theMPs()) != 0)
{
if(mpPtr->getNodeConstrained() == nodeID)
{
if(mpPtr->isTimeVarying() == true)
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; time-varying constraint"
<< " for node " << nodeID
<< " non-varying assumed\n";
const Matrix &C = mpPtr->getConstraint();
int numRows = C.noRows();
int numCols = C.noCols();
if(numRows != numCols)
std::cerr << getClassName() << "::" << __FUNCTION__
<< " constraint matrix not diagonal,"
<< " ignoring constraint for node "
<< nodeID << std::endl;
else
{
int ok = 0;
for(int i=0; i<numRows; i++)
{
if(C(i,i) != 1.0) ok = 1;
for(int j=0; j<numRows; j++)
if(i != j)
if(C(i,j) != 0.0)
ok = 1;
}
if(ok != 0)
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; constraint matrix not identity,"
<< " ignoring constraint for node "
<< nodeID << std::endl;
else
{
const ID &dofs = mpPtr->getConstrainedDOFs();
const ID &id = dofPtr->getID();
for(int i=0; i<dofs.Size(); i++)
{
int dof = dofs(i);
if(id(dof) == -2)
{
dofPtr->setID(dof,-4);
countDOF--;
}
else
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; constraint at dof " << dof
<< " already specified for constrained node"
<< " in MFreedom_Constraint at node "
<< nodeID << std::endl;
}
}
}
}
}
// loop through the MFreedom_Constraints to see if any of the
// DOFs are constrained, note constraint matrix must be diagonal
// with 1's on the diagonal
MRMFreedom_ConstraintIter &theMRMPs = theDomain->getConstraints().getMRMPs();
MRMFreedom_Constraint *mrmpPtr;
while((mrmpPtr = theMRMPs()) != 0)
{
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; loop through the MRMFreedom_Constraints."
<< std::endl;
}
}
// set the number of eqn in the model
theModel->setNumEqn(countDOF);
// now see if we have to set any of the dof's to -3
// int numLast = 0;
if(nodesLast != 0)
for(int i=0; i<nodesLast->Size(); i++)
{
int nodeID = (*nodesLast)(i);
Node *nodPtr = theDomain->getNode(nodeID);
if(nodPtr != 0)
{
dofPtr = nodPtr->getDOF_GroupPtr();
const ID &id = dofPtr->getID();
// set all the dof values to -3
for (int j=0; j < id.Size(); j++)
if(id(j) == -2)
{
dofPtr->setID(j,-3);
count3++;
}
else
std::cerr << getClassName() << "::" << __FUNCTION__
<< "; boundary sp constraint in subdomain"
<< " this should not be - results suspect \n";
}
}
// initialise the FE_Elements and add to the XC::AnalysisModel.
ElementIter &theEle = theDomain->getElements();
Element *elePtr;
int numFe = 0;
FE_Element *fePtr;
while((elePtr = theEle()) != 0)
{ fePtr= theModel->createFE_Element(numFe++, elePtr); }
return count3;
}
int
LagrangeConstraintHandler::handle(const ID *nodesLast)
{
// first check links exist to a Domain and an AnalysisModel object
Domain *theDomain = this->getDomainPtr();
AnalysisModel *theModel = this->getAnalysisModelPtr();
Integrator *theIntegrator = this->getIntegratorPtr();
if ((theDomain == 0) || (theModel == 0) || (theIntegrator == 0)) {
opserr << "WARNING LagrangeConstraintHandler::handle() - ";
opserr << " setLinks() has not been called\n";
return -1;
}
// get number ofelements and nodes in the domain
// and init the theFEs and theDOFs arrays
int numConstraints = 0;
SP_ConstraintIter &theSPss = theDomain->getDomainAndLoadPatternSPs();
SP_Constraint *spPtr;
while ((spPtr = theSPss()) != 0)
numConstraints++;
numConstraints += theDomain->getNumMPs();
//create a DOF_Group for each Node and add it to the AnalysisModel.
// : must of course set the initial IDs
NodeIter &theNod = theDomain->getNodes();
Node *nodPtr;
MP_Constraint *mpPtr;
DOF_Group *dofPtr;
int numDofGrp = 0;
int count3 = 0;
int countDOF =0;
while ((nodPtr = theNod()) != 0) {
if ((dofPtr = new DOF_Group(numDofGrp++, nodPtr)) == 0) {
opserr << "WARNING LagrangeConstraintHandler::handle() ";
opserr << "- ran out of memory";
opserr << " creating DOF_Group " << numDofGrp++ << endln;
return -4;
}
// initially set all the ID value to -2
const ID &id = dofPtr->getID();
for (int j=0; j < id.Size(); j++) {
dofPtr->setID(j,-2);
countDOF++;
}
nodPtr->setDOF_GroupPtr(dofPtr);
theModel->addDOF_Group(dofPtr);
}
// create the FE_Elements for the Elements and add to the AnalysisModel
ElementIter &theEle = theDomain->getElements();
Element *elePtr;
int numFeEle = 0;
FE_Element *fePtr;
while ((elePtr = theEle()) != 0) {
// only create an FE_Element for a subdomain element if it does not
// do independent analysis .. then subdomain part of this analysis so create
// an FE_element & set subdomain to point to it.
if (elePtr->isSubdomain() == true) {
Subdomain *theSub = (Subdomain *)elePtr;
if (theSub->doesIndependentAnalysis() == false) {
if ((fePtr = new FE_Element(numFeEle++, elePtr)) == 0) {
opserr << "WARNING PlainHandler::handle() - ran out of memory";
opserr << " creating FE_Element " << elePtr->getTag() << endln;
return -5;
}
theModel->addFE_Element(fePtr);
theSub->setFE_ElementPtr(fePtr);
} // if (theSub->doesIndependentAnalysis() == false) {
} else {
// just a regular element .. create an FE_Element for it & add to AnalysisModel
if ((fePtr = new FE_Element(numFeEle++, elePtr)) == 0) {
opserr << "WARNING PlainHandler::handle() - ran out of memory";
opserr << " creating FE_Element " << elePtr->getTag() << endln;
return -5;
}
theModel->addFE_Element(fePtr);
}
}
// create the LagrangeSP_FE for the SP_Constraints and
// add to the AnalysisModel
SP_ConstraintIter &theSPs = theDomain->getDomainAndLoadPatternSPs();
while ((spPtr = theSPs()) != 0) {
if ((dofPtr = new LagrangeDOF_Group(numDofGrp++, *spPtr)) == 0) {
opserr << "WARNING LagrangeConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating LagrangeDOFGroup " << endln;
return -5;
}
const ID &id = dofPtr->getID();
for (int j=0; j < id.Size(); j++) {
dofPtr->setID(j,-2);
countDOF++;
}
theModel->addDOF_Group(dofPtr);
if ((fePtr = new LagrangeSP_FE(numFeEle++, *theDomain, *spPtr,
*dofPtr, alphaSP)) == 0) {
opserr << "WARNING LagrangeConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating LagrangeSP_FE " << endln;
return -5;
}
theModel->addFE_Element(fePtr);
}
// create the LagrangeMP_FE for the MP_Constraints and
// add to the AnalysisModel
MP_ConstraintIter &theMPs = theDomain->getMPs();
while ((mpPtr = theMPs()) != 0) {
if ((dofPtr = new LagrangeDOF_Group(numDofGrp++, *mpPtr)) == 0) {
opserr << "WARNING LagrangeConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating LagrangeDOFGroup " << endln;
return -5;
}
const ID &id = dofPtr->getID();
for (int j=0; j < id.Size(); j++) {
dofPtr->setID(j,-2);
countDOF++;
}
theModel->addDOF_Group(dofPtr);
if ((fePtr = new LagrangeMP_FE(numFeEle++, *theDomain, *mpPtr,
*dofPtr, alphaMP)) == 0) {
opserr << "WARNING LagrangeConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating LagrangeMP_FE " << endln;
return -5;
}
theModel->addFE_Element(fePtr);
}
theModel->setNumEqn(countDOF);
// set the number of eqn in the model
// now see if we have to set any of the dof's to -3
// int numLast = 0;
if (nodesLast != 0)
for (int i=0; i<nodesLast->Size(); i++) {
int nodeID = (*nodesLast)(i);
Node *nodPtr = theDomain->getNode(nodeID);
if (nodPtr != 0) {
dofPtr = nodPtr->getDOF_GroupPtr();
const ID &id = dofPtr->getID();
// set all the dof values to -3
for (int j=0; j < id.Size(); j++)
if (id(j) == -2) {
dofPtr->setID(j,-3);
count3++;
} else {
opserr << "WARNING LagrangeConstraintHandler::handle() ";
opserr << " - boundary sp constraint in subdomain";
opserr << " this should not be - results suspect \n";
}
}
}
return count3;
}
int
TransformationConstraintHandler::handle(const ID *nodesLast)
{
// first check links exist to a Domain and an AnalysisModel object
Domain *theDomain = this->getDomainPtr();
AnalysisModel *theModel = this->getAnalysisModelPtr();
Integrator *theIntegrator = this->getIntegratorPtr();
if ((theDomain == 0) || (theModel == 0) || (theIntegrator == 0)) {
opserr << "WARNING TransformationConstraintHandler::handle() - ";
opserr << " setLinks() has not been called\n";
return -1;
}
// get number ofelements and nodes in the domain
// and init the theFEs and theDOFs arrays
int numMPConstraints = theDomain->getNumMPs();
// int numSPConstraints = theDomain->getNumSPs();
int numSPConstraints = 0;
SP_ConstraintIter &theSP1s = theDomain->getDomainAndLoadPatternSPs();
SP_Constraint *theSP1;
while ((theSP1 = theSP1s()) != 0)
numSPConstraints++;
numDOF = 0;
ID transformedNode(0, 64);
int i;
// create an ID of constrained node tags in MP_Constraints
ID constrainedNodesMP(0, numMPConstraints);
MP_Constraint **mps =0;
if (numMPConstraints != 0) {
mps = new MP_Constraint *[numMPConstraints];
if (mps == 0) {
opserr << "WARNING TransformationConstraintHandler::handle() - ";
opserr << "ran out of memory for MP_Constraints";
opserr << " array of size " << numMPConstraints << endln;
return -3;
}
MP_ConstraintIter &theMPs = theDomain->getMPs();
MP_Constraint *theMP;
int index = 0;
while ((theMP = theMPs()) != 0) {
int nodeConstrained = theMP->getNodeConstrained();
if (transformedNode.getLocation(nodeConstrained) < 0)
transformedNode[numDOF++] = nodeConstrained;
constrainedNodesMP[index] = nodeConstrained;
mps[index] = theMP;
index++;
}
}
// create an ID of constrained node tags in SP_Constraints
ID constrainedNodesSP(0, numSPConstraints);;
SP_Constraint **sps =0;
if (numSPConstraints != 0) {
sps = new SP_Constraint *[numSPConstraints];
if (sps == 0) {
opserr << "WARNING TransformationConstraintHandler::handle() - ";
opserr << "ran out of memory for SP_Constraints";
opserr << " array of size " << numSPConstraints << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -3;
}
SP_ConstraintIter &theSPs = theDomain->getDomainAndLoadPatternSPs();
SP_Constraint *theSP;
int index = 0;
while ((theSP = theSPs()) != 0) {
int constrainedNode = theSP->getNodeTag();
if (transformedNode.getLocation(constrainedNode) < 0)
transformedNode[numDOF++] = constrainedNode;
constrainedNodesSP[index] = constrainedNode;
sps[index] = theSP;
index++;
}
}
// create an array for the DOF_Groups and zero it
if ((numDOF != 0) && ((theDOFs = new DOF_Group *[numDOF]) == 0)) {
opserr << "WARNING TransformationConstraintHandler::handle() - ";
opserr << "ran out of memory for DOF_Groups";
opserr << " array of size " << numDOF << endln;
return -3;
}
for (i=0; i<numDOF; i++) theDOFs[i] = 0;
//create a DOF_Group for each Node and add it to the AnalysisModel.
// :must of course set the initial IDs
NodeIter &theNod = theDomain->getNodes();
Node *nodPtr;
int numDofGrp = 0;
int count3 = 0;
int countDOF =0;
numConstrainedNodes = 0;
numDOF = 0;
while ((nodPtr = theNod()) != 0) {
DOF_Group *dofPtr = 0;
int nodeTag = nodPtr->getTag();
int numNodalDOF = nodPtr->getNumberDOF();
int loc = -1;
int createdDOF = 0;
loc = constrainedNodesMP.getLocation(nodeTag);
if (loc >= 0) {
TransformationDOF_Group *tDofPtr =
new TransformationDOF_Group(numDofGrp++, nodPtr, mps[loc], this);
createdDOF = 1;
dofPtr = tDofPtr;
// add any SPs
if (numSPConstraints != 0) {
loc = constrainedNodesSP.getLocation(nodeTag);
if (loc >= 0) {
tDofPtr->addSP_Constraint(*(sps[loc]));
for (int i = loc+1; i<numSPConstraints; i++) {
if (constrainedNodesSP(i) == nodeTag)
tDofPtr->addSP_Constraint(*(sps[i]));
}
}
// add the DOF to the array
theDOFs[numDOF++] = dofPtr;
numConstrainedNodes++;
}
}
if (createdDOF == 0) {
loc = constrainedNodesSP.getLocation(nodeTag);
if (loc >= 0) {
TransformationDOF_Group *tDofPtr =
new TransformationDOF_Group(numDofGrp++, nodPtr, this);
int numSPs = 1;
createdDOF = 1;
dofPtr = tDofPtr;
tDofPtr->addSP_Constraint(*(sps[loc]));
// check for more SP_constraints acting on node and add them
for (int i = loc+1; i<numSPConstraints; i++) {
if (constrainedNodesSP(i) == nodeTag) {
tDofPtr->addSP_Constraint(*(sps[i]));
numSPs++;
}
}
// add the DOF to the array
theDOFs[numDOF++] = dofPtr;
numConstrainedNodes++;
countDOF+= numNodalDOF - numSPs;
}
}
// create an ordinary DOF_Group object if no dof constrained
if (createdDOF == 0) {
if ((dofPtr = new DOF_Group(numDofGrp++, nodPtr)) == 0) {
opserr << "WARNING TransformationConstraintHandler::handle() ";
opserr << "- ran out of memory";
opserr << " creating DOF_Group " << i << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -4;
}
countDOF+= numNodalDOF;
}
if (dofPtr == 0)
opserr << "TransformationConstraintHandler::handle() - error in logic\n";
nodPtr->setDOF_GroupPtr(dofPtr);
theModel->addDOF_Group(dofPtr);
}
// create the FE_Elements for the Elements and add to the AnalysisModel
ElementIter &theEle = theDomain->getElements();
Element *elePtr;
FE_Element *fePtr;
numFE = 0;
ID transformedEle(0, 64);
while ((elePtr = theEle()) != 0) {
int flag = 0;
if (elePtr->isSubdomain() == true) {
Subdomain *theSub = (Subdomain *)elePtr;
if (theSub->doesIndependentAnalysis() == true)
flag = 1;
}
if (flag == 0) {
const ID &nodes = elePtr->getExternalNodes();
int nodesSize = nodes.Size();
int isConstrainedNode = 0;
for (int i=0; i<nodesSize; i++) {
int nodeTag = nodes(i);
if (numMPConstraints != 0) {
int loc = constrainedNodesMP.getLocation(nodeTag);
if (loc >= 0) {
isConstrainedNode = 1;
i = nodesSize;
}
}
if (numSPConstraints != 0 && isConstrainedNode == 0) {
int loc = constrainedNodesSP.getLocation(nodeTag);
if (loc >= 0) {
isConstrainedNode = 1;
i = nodesSize;
}
}
}
if (isConstrainedNode == 1) {
transformedEle[numFE++] = elePtr->getTag();
}
}
}
// create an array for the FE_elements and zero it
if ((numFE != 0) && ((theFEs = new FE_Element *[numFE]) == 0)) {
opserr << "WARNING TransformationConstraintHandler::handle() - ";
opserr << "ran out of memory for FE_elements";
opserr << " array of size " << numFE << endln;
return -2;
}
for (i=0; i<numFE; i++) theFEs[i] = 0;
ElementIter &theEle1 = theDomain->getElements();
// int numConstraints = numMPConstraints+numSPConstraints;
int numFeEle = 0;
int numFE = 0;
while ((elePtr = theEle1()) != 0) {
int tag = elePtr->getTag();
if (elePtr->isSubdomain() == true) {
Subdomain *theSub = (Subdomain *)elePtr;
if (theSub->doesIndependentAnalysis() == false) {
if (transformedEle.getLocation(tag) < 0) {
if ((fePtr = new FE_Element(numFeEle, elePtr)) == 0) {
opserr << "WARNING TransformationConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating FE_Element " << elePtr->getTag() << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -5;
}
} else {
if ((fePtr = new TransformationFE(numFeEle, elePtr)) == 0) {
opserr << "WARNING TransformationConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating TransformationFE " << elePtr->getTag() << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -6;
}
theFEs[numFE++] = fePtr;
}
numFeEle++;
theModel->addFE_Element(fePtr);
theSub->setFE_ElementPtr(fePtr);
}
} else {
if (transformedEle.getLocation(tag) < 0) {
if ((fePtr = new FE_Element(numFeEle, elePtr)) == 0) {
opserr << "WARNING TransformationConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating FE_Element " << elePtr->getTag() << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -5;
}
} else {
if ((fePtr = new TransformationFE(numFeEle, elePtr)) == 0) {
opserr << "WARNING TransformationConstraintHandler::handle()";
opserr << " - ran out of memory";
opserr << " creating TransformationFE " << elePtr->getTag() << endln;
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return -6;
}
theFEs[numFE++] = fePtr;
}
numFeEle++;
theModel->addFE_Element(fePtr);
}
}
theModel->setNumEqn(countDOF);
// set the number of eqn in the model
// now see if we have to set any of the dof's to -3
// int numLast = 0;
if (nodesLast != 0)
for (i=0; i<nodesLast->Size(); i++) {
int nodeID = (*nodesLast)(i);
Node *nodPtr = theDomain->getNode(nodeID);
if (nodPtr != 0) {
DOF_Group *dofPtr = nodPtr->getDOF_GroupPtr();
const ID &id = dofPtr->getID();
// set all the dof values to -3
for (int j=0; j < id.Size(); j++) {
if (id(j) == -2) {
dofPtr->setID(j,-3);
count3++;
} else {
opserr << "WARNING TransformationConstraintHandler::handle() ";
opserr << " - boundary sp constraint in subdomain";
opserr << " this should not be - results suspect \n";
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
}
}
}
}
if (mps != 0) delete [] mps;
if (sps != 0) delete [] sps;
return count3;
}
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
MeshRegion::setNodes(const ID &theNods)
{
// destroy the old lists
if (theNodes != 0)
delete theNodes;
if (theElements != 0)
delete theElements;
//
// create new element & node lists
//
// create empty lists
Domain *theDomain = this->getDomain();
if (theDomain == 0) {
opserr << "MeshRegion::setNodes() - no domain yet set\n";
return -1;
}
int numNodes = theNods.Size();
theNodes = new ID(0, numNodes);
theElements = new ID(0, numNodes);
if (theNodes == 0 || theElements == 0) {
opserr << "MeshRegion::setElements() - ran out of memory\n";
return -1;
}
// add nodes to the node list if in the domain
int loc = 0;
for (int i=0; i<numNodes; i++) {
int nodeTag = theNods(i);
Node *theNode = theDomain->getNode(nodeTag);
if (theNode != 0) {
if (theNodes->getLocation(nodeTag) < 0)
(*theNodes)[loc++] = nodeTag;
}
}
// now loop over the ele to create the ele list
// NOTE - ele added to list if all it's nodes are in the region
loc = 0;
ElementIter &theEles = theDomain->getElements();
Element *theEle;
// loop over all ele
while ((theEle = theEles()) != 0) {
int eleTag = theEle->getTag();
// check to see if all external nodes in node list
bool in = true;
const ID &theEleNodes = theEle->getExternalNodes();
int numNodes = theEleNodes.Size();
for (int i=0; i<numNodes; i++) {
int nodeTag = theEleNodes(i);
if (theNodes->getLocation(nodeTag) < 0) {
in = false;
i = numNodes;
}
}
// if they are all in the node list add the ele to ele list
if (in == true)
(*theElements)[loc++] = eleTag;
}
return 0;
}
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;
}
