mObject nodesToJSON(void) { NodeIter &theNodes = theDomain.getNodes(); Node *theNode; const Vector *nodalCrds = NULL; int size; int i, ndf; mObject nodes; mArray coords; mValue tag, coord; char tag_str[15]; nodes.clear(); while ((theNode = theNodes()) != 0) { nodalCrds = &(theNode->getCrds()); ndf = theNode->getNumberDOF(); tag = theNode->getTag(); size = nodalCrds->Size(); coords.clear(); for (i = 0; i < size; i++) { coord = (*nodalCrds)(i); coords.push_back(coord); } sprintf(tag_str, "%d", tag.get_int()); nodes[tag_str] = coords; } return nodes; }
mObject massesToJSON(void) { NodeIter &theNodes = theDomain.getNodes(); Node *theNode; const Matrix *mass = NULL; int i, ndf; mObject ret; mArray masses; mValue tag, tmp; char tag_str[15]; ret.clear(); while ((theNode = theNodes()) != 0) { ndf = theNode->getNumberDOF(); mass = &(theNode->getMass()); tag = theNode->getTag(); masses.clear(); for (i = 0; i < ndf; i++) { tmp = (*mass)(i, i); masses.push_back(tmp); } sprintf(tag_str, "%d", tag.get_int()); ret[tag_str] = masses; } return ret; }
mObject nodesDispToJSON(void) { NodeIter &theNodes = theDomain.getNodes(); Node *theNode; const Vector *nodalResponse; int size; int i; mObject disp_field, result; mArray nodal_disps; mValue tag, disp; char tag_str[15]; // TODO: The field 'time' shouldn't be here, but old SketchIT depends on it, for compatibilty. mValue ctime = theDomain.getCurrentTime(); result["time"] = ctime; disp_field.clear(); while ((theNode = theNodes()) != 0) { nodalResponse = theNode->getResponse(Disp); size = nodalResponse->Size(); nodal_disps.clear(); for (i = 0; i < size; i++) { disp = (*nodalResponse)(i); nodal_disps.push_back(disp); } tag = theNode->getTag(); sprintf(tag_str, "%d", tag.get_int()); disp_field[tag_str] = nodal_disps; } result["disp"] = disp_field; return result; };
void LagrangeConstraintHandler::clearAll(void) { // for the nodes reset the DOF_Group pointers to 0 Domain *theDomain = this->getDomainPtr(); if (theDomain == 0) return; NodeIter &theNod = theDomain->getNodes(); Node *nodPtr; while ((nodPtr = theNod()) != 0) nodPtr->setDOF_GroupPtr(0); }
int Mesh::nextNodeTag() { Domain* domain = OPS_GetDomain(); if (domain == 0) { opserr << "WARNING: domain is not created\n"; return -1; } NodeIter& nodes = domain->getNodes(); Node* node = 0; int ndtag = 0; while((node = nodes()) != 0) { ndtag = node->getTag(); } return ndtag+1; }
void UniformExcitation::applyLoadSensitivity(double time) { Domain *theDomain = this->getDomain(); if (theDomain == 0) return; // if (numNodes != theDomain->getNumNodes()) { NodeIter &theNodes = theDomain->getNodes(); Node *theNode; while ((theNode = theNodes()) != 0) { theNode->setNumColR(1); theNode->setR(theDof, 0, 1.0); } // } this->EarthquakePattern::applyLoadSensitivity(time); return; }
void TransformationConstraintHandler::clearAll(void) { // delete the arrays if (theFEs != 0) delete [] theFEs; if (theDOFs != 0) delete [] theDOFs; // reset the numbers numDOF = 0; numFE = 0; theFEs = 0; theDOFs = 0; // for the nodes reset the DOF_Group pointers to 0 Domain *theDomain = this->getDomainPtr(); if (theDomain == 0) return; NodeIter &theNod = theDomain->getNodes(); Node *nodPtr; while ((nodPtr = theNod()) != 0) nodPtr->setDOF_GroupPtr(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 PFEMIntegrator::formSensitivityRHS(int passedGradNumber) { sensitivityFlag = 1; // Set a couple of data members gradNumber = passedGradNumber; // Get pointer to the SOE LinearSOE *theSOE = this->getLinearSOE(); // Get the analysis model AnalysisModel *theModel = this->getAnalysisModel(); // Randomness in external load (including randomness in time series) // Get domain Domain *theDomain = theModel->getDomainPtr(); // Loop through nodes to zero the unbalaced load Node *nodePtr; NodeIter &theNodeIter = theDomain->getNodes(); while ((nodePtr = theNodeIter()) != 0) nodePtr->zeroUnbalancedLoad(); // Loop through load patterns to add external load sensitivity LoadPattern *loadPatternPtr; LoadPatternIter &thePatterns = theDomain->getLoadPatterns(); double time; while((loadPatternPtr = thePatterns()) != 0) { time = theDomain->getCurrentTime(); loadPatternPtr->applyLoadSensitivity(time); } // Randomness in element/material contributions // Loop through FE elements FE_Element *elePtr; FE_EleIter &theEles = theModel->getFEs(); while((elePtr = theEles()) != 0) { theSOE->addB( elePtr->getResidual(this), elePtr->getID() ); } // Loop through DOF groups (IT IS IMPORTANT THAT THIS IS DONE LAST!) DOF_Group *dofPtr; DOF_GrpIter &theDOFs = theModel->getDOFs(); while((dofPtr = theDOFs()) != 0) { theSOE->addB( dofPtr->getUnbalance(this), dofPtr->getID() ); } // Reset the sensitivity flag sensitivityFlag = 0; return 0; }