int
IncrementalIntegrator::doMv(const Vector &v, Vector &res) {
int n = v.Size();
if (isDiagonal == true) {
for (int i=0; i<n; i++)
res[i] = diagMass[i]*v[i];
return 0;
}
res.Zero();
// loop over the FE_Elements
FE_Element *elePtr;
FE_EleIter &theEles = theAnalysisModel->getFEs();
while((elePtr = theEles()) != 0) {
const Vector &b = elePtr->getM_Force(v, 1.0);
res.Assemble(b, elePtr->getID(), 1.0);
}
// loop over the DOF_Groups
DOF_Group *dofPtr;
DOF_GrpIter &theDofs = theAnalysisModel->getDOFs();
while ((dofPtr = theDofs()) != 0) {
const Vector &a = dofPtr->getM_Force(v, 1.0);
res.Assemble(a, dofPtr->getID(), 1.0);
}
return 0;
}
void
BandArpackSolver::myMv(int n, double *v, double *result)
{
Vector x(v, n);
Vector y(result,n);
y.Zero();
AnalysisModel *theAnalysisModel = theSOE->theModel;
// loop over the FE_Elements
FE_Element *elePtr;
FE_EleIter &theEles = theAnalysisModel->getFEs();
while((elePtr = theEles()) != 0) {
const Vector &b = elePtr->getM_Force(x, 1.0);
y.Assemble(b, elePtr->getID(), 1.0);
}
// loop over the DOF_Groups
DOF_Group *dofPtr;
DOF_GrpIter &theDofs = theAnalysisModel->getDOFs();
Integrator *theIntegrator = 0;
while ((dofPtr = theDofs()) != 0) {
const Vector &a = dofPtr->getM_Force(x,1.0);
y.Assemble(a,dofPtr->getID(),1.0);
}
}
// void setID(int index, int value);
// Method to set the correSPonding index of the ID to value.
int
LagrangeSP_FE::setID(void)
{
int result = 0;
// first determine the IDs in myID for those DOFs marked
// as constrained DOFs, this is obtained from the DOF_Group
// associated with the constrained node
DOF_Group *theNodesDOFs = theNode->getDOF_GroupPtr();
if (theNodesDOFs == 0) {
opserr << "WARNING LagrangeSP_FE::setID(void)";
opserr << " - no DOF_Group with Constrained Node\n";
return -1;
}
int restrainedDOF = theSP->getDOF_Number();
const ID &theNodesID = theNodesDOFs->getID();
if (restrainedDOF < 0 || restrainedDOF >= theNodesID.Size()) {
opserr << "WARNING LagrangeSP_FE::setID(void)";
opserr << " - restrained DOF invalid\n";
return -2;
}
myID(0) = theNodesID(restrainedDOF);
myID(1) = (theDofGroup->getID())(0);
return result;
}
int
RitzIntegrator::formM()
{
if (theAnalysisModel == 0 || theSOE == 0) {
opserr << "WARNING RitzIntegrator::formM -";
opserr << " no AnalysisModel or EigenSOE has been set\n";
return -1;
}
// the loops to form and add the tangents are broken into two for
// efficiency when performing parallel computations
// loop through the FE_Elements getting them to form the tangent
// FE_EleIter &theEles1 = theAnalysisModel->getFEs();
FE_Element *elePtr;
flagK = 1;
theSOE->zeroM();
// while((elePtr = theEles1()) != 0)
// elePtr->formTangent(this);
// loop through the FE_Elements getting them to add the tangent
int result = 0;
FE_EleIter &theEles2 = theAnalysisModel->getFEs();
while((elePtr = theEles2()) != 0) {
if (theSOE->addM(elePtr->getTangent(this), elePtr->getID()) < 0) {
opserr << "WARNING RitzIntegrator::formM -";
opserr << " failed in addM for ID " << elePtr->getID();
result = -2;
}
}
DOF_Group *dofPtr;
DOF_GrpIter &theDofs = theAnalysisModel->getDOFs();
while((dofPtr = theDofs()) != 0) {
// dofPtr->formTangent(this);
if (theSOE->addM(dofPtr->getTangent(this),dofPtr->getID()) < 0) {
opserr << "WARNING RitzIntegrator::formM -";
opserr << " failed in addM for ID " << dofPtr->getID();
result = -3;
}
}
return result;
}
int
PFEMIntegrator::saveSensitivity(const Vector & dVNew,int gradNum,int numGrads)
{
// Recover sensitivity results from previous step
int vectorSize = U->Size();
Vector dUn(vectorSize);
dVn.resize(vectorSize); dVn.Zero();
AnalysisModel *myModel = this->getAnalysisModel();
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
const Vector &dispSens = dofPtr->getDispSensitivity(gradNumber);
for (int i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
dUn(loc) = dispSens(i);
}
}
const Vector &velSens = dofPtr->getVelSensitivity(gradNumber);
for (int i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
dVn(loc) = velSens(i);
}
}
}
// Compute new acceleration and velocity vectors:
Vector dUNew(vectorSize);
Vector dANew(vectorSize);
// dudotdot = 1/dt*dv{n+1} - 1/dt*dvn
dANew.addVector(0.0, dVNew, c3);
dANew.addVector(1.0, dVn, -c3);
// du = dun + dt*dv{n+1}
dUNew.addVector(0.0, dVNew, c1);
dUNew.addVector(1.0, dUn, 1.0);
// Now we can save vNew, vdotNew and vdotdotNew
DOF_GrpIter &theDOFGrps = myModel->getDOFs();
DOF_Group *dofPtr1;
while ( (dofPtr1 = theDOFGrps() ) != 0) {
dofPtr1->saveSensitivity(dUNew,dVNew,dANew,gradNum,numGrads);
}
return 0;
}
int
IncrementalIntegrator::formNodalUnbalance(void)
{
// loop through the DOF_Groups and add the unbalance
DOF_GrpIter &theDOFs = theAnalysisModel->getDOFs();
DOF_Group *dofPtr;
int res = 0;
while ((dofPtr = theDOFs()) != 0) {
// opserr << "NODPTR: " << dofPtr->getUnbalance(this);
if (theSOE->addB(dofPtr->getUnbalance(this),dofPtr->getID()) <0) {
opserr << "WARNING IncrementalIntegrator::formNodalUnbalance -";
opserr << " failed in addB for ID " << dofPtr->getID();
res = -2;
}
}
return res;
}
int XC::Subdomain::buildMap(void) const
{
if(mapBuilt == false)
{
// determine the mapping between local dof and subdomain ana dof
int numDOF = this->getNumDOF();
if(map == nullptr)
map = new ID(numDOF);
if(map->Size() != numDOF)
{
delete map;
map = new ID(numDOF);
}
//int numExt = theAnalysis->getNumExternalEqn();
int numInt = theAnalysis->getNumInternalEqn();
const ID &theExtNodes = this->getExternalNodes();
int numExtNodes = theExtNodes.Size();
int locInMap =0;
for(int i=0; i<numExtNodes; i++)
{
Node *nodePtr= const_cast<Node *>(this->getNode(theExtNodes(i)));
int numNodeDOF = nodePtr->getNumberDOF();
DOF_Group *theDOF = nodePtr->getDOF_GroupPtr();
const ID &theLocalID = theDOF->getID();
for(int j=0; j<numNodeDOF; j++)
{
int locInSubdomainExt = theLocalID(j)-numInt;
(*map)(locInMap)=locInSubdomainExt;
locInMap++;
}
}
mapBuilt = true;
if(mappedVect == nullptr)
mappedVect = new Vector(numDOF);
if(mappedVect->Size() != numDOF)
{
delete mappedVect;
mappedVect = new Vector(numDOF);
}
if(mappedMatrix == nullptr)
mappedMatrix = new Matrix(numDOF,numDOF);
if(mappedMatrix->noRows() != numDOF)
{
delete mappedMatrix;
mappedMatrix = new Matrix(numDOF,numDOF);
}
}
return 0;
}
int
IncrementalIntegrator::addModalDampingForce(void)
{
int res = 0;
if (modalDampingValues == 0)
return 0;
int numModes = modalDampingValues->Size();
const Vector &eigenvalues = theAnalysisModel->getEigenvalues();
if (eigenvalues.Size() < numModes)
numModes = eigenvalues.Size();
Vector dampingForces(theSOE->getNumEqn());
dampingForces.Zero();
for (int i=0; i<numModes; i++) {
DOF_GrpIter &theDOFs1 = theAnalysisModel->getDOFs();
DOF_Group *dofPtr;
double beta = 0.0;
double eigenvalue = eigenvalues(i); // theEigenSOE->getEigenvalue(i+1);
double wn = 0.;
if (eigenvalue > 0)
wn = sqrt(eigenvalue);
while ((dofPtr = theDOFs1()) != 0) {
beta += dofPtr->getDampingBetaFactor(i, (*modalDampingValues)(i), wn);
}
DOF_GrpIter &theDOFs2 = theAnalysisModel->getDOFs();
while ((dofPtr = theDOFs2()) != 0) {
if (theSOE->addB(dofPtr->getDampingBetaForce(i, beta),dofPtr->getID()) <0) {
opserr << "WARNING IncrementalIntegrator::failed in dofPtr";
res = -1;
}
}
}
return res;
}
int
TransientIntegrator::formTangent(int statFlag)
{
int result = 0;
statusFlag = statFlag;
LinearSOE *theLinSOE = this->getLinearSOE();
AnalysisModel *theModel = this->getAnalysisModel();
if (theLinSOE == 0 || theModel == 0) {
opserr << "WARNING TransientIntegrator::formTangent() ";
opserr << "no LinearSOE or AnalysisModel has been set\n";
return -1;
}
// the loops to form and add the tangents are broken into two for
// efficiency when performing parallel computations
theLinSOE->zeroA();
// loop through the DOF_Groups and add the unbalance
DOF_GrpIter &theDOFs = theModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
if (theLinSOE->addA(dofPtr->getTangent(this),dofPtr->getID()) <0) {
opserr << "TransientIntegrator::formTangent() - failed to addA:dof\n";
result = -1;
}
}
// loop through the FE_Elements getting them to add the tangent
FE_EleIter &theEles2 = theModel->getFEs();
FE_Element *elePtr;
while((elePtr = theEles2()) != 0) {
if (theLinSOE->addA(elePtr->getTangent(this),elePtr->getID()) < 0) {
opserr << "TransientIntegrator::formTangent() - failed to addA:ele\n";
result = -2;
}
}
return result;
}
int
NewmarkSensitivityIntegrator::formEleResidual(FE_Element *theEle)
{
if (sensitivityFlag == 0) { // NO SENSITIVITY ANALYSIS
this->Newmark::formEleResidual(theEle);
}
else { // (ASSEMBLE ALL TERMS)
theEle->zeroResidual();
// Compute the time-stepping parameters on the form
// udotdot = a1*ui+1 + a2*ui + a3*udoti + a4*udotdoti
// udot = a5*ui+1 + a6*ui + a7*udoti + a8*udotdoti
// (see p. 166 of Chopra)
// The constants are:
// a1 = 1.0/(beta*dt*dt)
// a2 = -1.0/(beta*dt*dt)
// a3 = -1.0/beta*dt
// a4 = 1.0 - 1.0/(2.0*beta)
// a5 = gamma/(beta*dt)
// a6 = -gamma/(beta*dt)
// a7 = 1.0 - gamma/beta
// a8 = 1.0 - gamma/(2.0*beta)
// We can make use of the data members c2 and c3 of this class.
// As long as disp==true, they are defined as:
// c2 = gamma/(beta*dt)
// c3 = 1.0/(beta*dt*dt)
// So, the constants can be computed as follows:
if (displ==false) {
opserr << "ERROR: Newmark::formEleResidual() -- the implemented"
<< " scheme only works if the displ variable is set to true." << endln;
}
double a2 = -c3;
double a3 = -c2/gamma;
double a4 = 1.0 - 1.0/(2.0*beta);
double a6 = -c2;
double a7 = 1.0 - gamma/beta;
double dt = gamma/(beta*c2);
double a8 = dt*(1.0 - gamma/(2.0*beta));
// Obtain sensitivity vectors from previous step
int vectorSize = U->Size();
Vector V(vectorSize);
Vector Vdot(vectorSize);
Vector Vdotdot(vectorSize);
int i, loc;
AnalysisModel *myModel = this->getAnalysisModel();
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
const Vector &dispSens = dofPtr->getDispSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
V(loc) = dispSens(i);
}
}
const Vector &velSens = dofPtr->getVelSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
Vdot(loc) = velSens(i);
}
}
const Vector &accelSens = dofPtr->getAccSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
Vdotdot(loc) = accelSens(i);
}
}
}
// Pre-compute the vectors involving a2, a3, etc.
//Vector tmp1 = V*a2 + Vdot*a3 + Vdotdot*a4;
Vector tmp1(vectorSize);
tmp1.addVector(0.0, V, a2);
tmp1.addVector(1.0, Vdot, a3);
tmp1.addVector(1.0, Vdotdot, a4);
//Vector tmp2 = V*a6 + Vdot*a7 + Vdotdot*a8;
Vector tmp2(vectorSize);
tmp2.addVector(0.0, V, a6);
tmp2.addVector(1.0, Vdot, a7);
tmp2.addVector(1.0, Vdotdot, a8);
if (massMatrixMultiplicator == 0)
massMatrixMultiplicator = new Vector(tmp1.Size());
if (dampingMatrixMultiplicator == 0)
dampingMatrixMultiplicator = new Vector(tmp2.Size());
(*massMatrixMultiplicator) = tmp1;
(*dampingMatrixMultiplicator) = tmp2;
// Now we're ready to make calls to the FE Element:
// The term -dPint/dh|u fixed
theEle->addResistingForceSensitivity(gradNumber);
// The term -dM/dh*acc
theEle->addM_ForceSensitivity(gradNumber, *Udotdot, -1.0);
// The term -M*(a2*v + a3*vdot + a4*vdotdot)
theEle->addM_Force(*massMatrixMultiplicator,-1.0);
// The term -C*(a6*v + a7*vdot + a8*vdotdot)
theEle->addD_Force(*dampingMatrixMultiplicator,-1.0);
// The term -dC/dh*vel
theEle->addD_ForceSensitivity(gradNumber, *Udot,-1.0);
}
return 0;
}
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;
}
int XC::ParallelNumberer::numberDOF(int lastDOF)
{
int result = 0;
// get a pointer to the model & check its not null
AnalysisModel *theModel = this->getAnalysisModelPtr();
Domain *theDomain = 0;
if(theModel) theDomain = theModel->getDomainPtr();
if(theModel == 0 || theDomain == 0)
{
std::cerr << "WARNING XC::ParallelNumberer::numberDOF(int) -";
std::cerr << " - no AnalysisModel.\n";
return -1;
}
if(lastDOF != -1)
{
std::cerr << "WARNING XC::ParallelNumberer::numberDOF(int lastDOF):";
std::cerr << " does not use the lastDOF as requested\n";
}
Graph &theGraph= theModel->getDOFGroupGraph();
// if subdomain, collect graph, send it off, get
// ID back containing dof tags & start id numbers.
if(processID != 0)
{
CommParameters cp(0,*theChannels[0]);
const int numVertex = theGraph.getNumVertex();
/*
static XC::ID test(2); test(0) = processID; test(1) = 25;
theChannel->recvID(0, 0, test);
*/
cp.sendMovable(theGraph,DistributedObj::getDbTagData(),CommMetaData(1));
// recv iD
ID theID(2*numVertex);
cp.receiveID(theID,DistributedObj::getDbTagData(),CommMetaData(2));
// set vertex numbering based on ID received
for(int i=0; i<numVertex; i ++)
{
const int vertexTag= theID(i);
int startID= theID(i+numVertex);
//Vertex *vertexPtr = theGraph.getVertexPtr(vertexTag);
const int dofTag= vertexTag;
DOF_Group *dofPtr= theModel->getDOF_GroupPtr(dofTag);
if(!dofPtr)
{
std::cerr << "WARNING ParallelNumberer::numberDOF - ";
std::cerr << "DOF_Group " << dofTag << "not in XC::AnalysisModel!\n";
result= -4;
}
else
{
const ID &theDOFID= dofPtr->getID();
//std::cerr << "P: " << processID << " dofTag: " << dofTag << " " << "start: " << startID << " " << theDOFID;
const int idSize= theDOFID.Size();
for(int j=0; j<idSize; j++)
if(theDOFID(j) == -2 || theDOFID(j) == -3) dofPtr->setID(j, startID++);
}
//const ID &theDOFID= dofPtr->getID();
}
cp.sendID(theID,DistributedObj::getDbTagData(),CommMetaData(2));
}
else
{
// if XC::main domain, collect graphs from all subdomains,
// merge into 1, number this one, send to subdomains the
// id containing dof tags & start id's.
// for P0 domain determine original vertex and ref tags
const int numVertex= theGraph.getNumVertex();
const int numVertexP0= numVertex;
ID vertexTags(numVertex);
ID vertexRefs(numVertex);
Vertex *vertexPtr;
int loc= 0;
VertexIter &theVertices= theGraph.getVertices();
while((vertexPtr= theVertices()) != 0)
{
vertexTags[loc]= vertexPtr->getTag();
vertexRefs[loc]= vertexPtr->getRef();
loc++;
}
const int numChannels= theChannels.size();
std::vector<ID> theSubdomainIDs(numChannels);
FEM_ObjectBroker theBroker;
// for each subdomain we receive graph, create an XC::ID (to store
// subdomain graph to merged graph vertex mapping and the final
// subdoain graph vertex to startDOF mapping) and finally merge the
// subdomain graph
for(int j=0; j<numChannels; j++)
{
CommParameters cp(0,*theChannels[j]);
Graph theSubGraph;
/*
static XC::ID test(2); test(0)= processID; test(1)= 25;
theChannel->sendID(0, 0, test);
*/
cp.receiveMovable(theSubGraph,DistributedObj::getDbTagData(),CommMetaData(3));
theSubdomainIDs[j]= ID(theSubGraph.getNumVertex()*2);
this->mergeSubGraph(theGraph, theSubGraph, vertexTags, vertexRefs, theSubdomainIDs[j]);
}
// we use graph numberer if one was provided in constructor,
// otherwise we number based on subdomains (all in subdomain 1 numbered first,
// then those in 2 not in 1 and so on till done.
// GraphNumberer *theNumberer= this->getGraphNumbererPtr();
ID theOrderedRefs(theGraph.getNumVertex());
if(theNumberer)
{
// use the supplied graph numberer to number the merged graph
theOrderedRefs= theNumberer->number(theGraph, lastDOF);
}
else
{
// assign numbers based on the subdomains
int loc= 0;
for(int l=0; l<numChannels; l++)
{
const ID &theSubdomain= theSubdomainIDs[l];
int numVertexSubdomain= theSubdomain.Size()/2;
for(int i=0; i<numVertexSubdomain; i++)
{
const int vertexTagMerged= theSubdomain(i+numVertexSubdomain);
// int refTag= vertexRefs[vertexTags.getLocation(vertexTagMerged)];
if(theOrderedRefs.getLocation(vertexTagMerged) == -1)
theOrderedRefs[loc++]= vertexTagMerged;
}
}
// now order those not yet ordered in p0
for(int j=0; j<numVertexP0; j++)
{
int refTagP0= vertexTags[j];
if(theOrderedRefs.getLocation(refTagP0) == -1)
theOrderedRefs[loc++]= refTagP0;
}
}
int count= 0;
for(int i=0; i<theOrderedRefs.Size(); i++)
{
int vertexTag= theOrderedRefs(i);
// int vertexTag= vertexTags[vertexRefs.getLocation(tag)];
Vertex *vertexPtr= theGraph.getVertexPtr(vertexTag);
int numDOF= vertexPtr->getColor();
vertexPtr->setTmp(count);
count += numDOF;
}
// number own dof's
for(int i=0; i<numVertexP0; i++ ) {
int vertexTag= vertexTags(i);
Vertex *vertexPtr= theGraph.getVertexPtr(vertexTag);
int startID= vertexPtr->getTmp();
int dofTag= vertexTag;
DOF_Group *dofPtr;
dofPtr= theModel->getDOF_GroupPtr(dofTag);
if(dofPtr == 0) {
std::cerr << "WARNING XC::ParallelNumberer::numberDOF - ";
std::cerr << "DOF_Group (P0) " << dofTag << "not in XC::AnalysisModel!\n";
result= -4;
} else {
const ID &theDOFID= dofPtr->getID();
int idSize= theDOFID.Size();
for(int j=0; j<idSize; j++)
if(theDOFID(j) == -2 || theDOFID(j) == -3) dofPtr->setID(j, startID++);
}
}
// now given the ordered refs we determine the mapping for each subdomain
// and send the id with the information back to the subdomain, which it uses to order
// it's own graph
for(int k=0; k<numChannels; k++)
{
CommParameters cp(0,*theChannels[k]);
ID &theSubdomain= theSubdomainIDs[k];
int numVertexSubdomain= theSubdomain.Size()/2;
for(int i=0; i<numVertexSubdomain; i++)
{
int vertexTagMerged= theSubdomain[numVertexSubdomain+i];
Vertex *vertexPtr= theGraph.getVertexPtr(vertexTagMerged);
int startDOF= vertexPtr->getTmp();
theSubdomain[i+numVertexSubdomain]= startDOF;
}
cp.sendID(theSubdomain,DistributedObj::getDbTagData(),CommMetaData(4));
cp.receiveID(theSubdomain,DistributedObj::getDbTagData(),CommMetaData(4));
}
}
// iterate through the XC::FE_Element getting them to set their IDs
FE_EleIter &theEle= theModel->getFEs();
FE_Element *elePtr;
while ((elePtr= theEle()) != 0)
elePtr->setID();
return result;
}
int
DirectIntegrationAnalysis::eigen(int numMode, bool generalized)
{
if (theAnalysisModel == 0 || theEigenSOE == 0) {
opserr << "WARNING DirectIntegrationAnalysis::eigen() - no EigenSOE has been set\n";
return -1;
}
int result = 0;
Domain *the_Domain = this->getDomainPtr();
result = theAnalysisModel->eigenAnalysis(numMode, generalized);
int stamp = the_Domain->hasDomainChanged();
if (stamp != domainStamp) {
domainStamp = stamp;
result = this->domainChanged();
if (result < 0) {
opserr << "DirectIntegrationAnalysis::eigen() - domainChanged failed";
return -1;
}
}
//
// zero A and M
//
theEigenSOE->zeroA();
theEigenSOE->zeroM();
//
// form K
//
FE_EleIter &theEles = theAnalysisModel->getFEs();
FE_Element *elePtr;
while((elePtr = theEles()) != 0) {
elePtr->zeroTangent();
elePtr->addKtToTang(1.0);
if (theEigenSOE->addA(elePtr->getTangent(0), elePtr->getID()) < 0) {
opserr << "WARNING DirectIntegrationAnalysis::eigen() -";
opserr << " failed in addA for ID " << elePtr->getID();
result = -2;
}
}
//
// if generalized is true, form M
//
if (generalized == true) {
int result = 0;
FE_EleIter &theEles2 = theAnalysisModel->getFEs();
while((elePtr = theEles2()) != 0) {
elePtr->zeroTangent();
elePtr->addMtoTang(1.0);
if (theEigenSOE->addM(elePtr->getTangent(0), elePtr->getID()) < 0) {
opserr << "WARNING DirectIntegrationAnalysis::eigen() -";
opserr << " failed in addA for ID " << elePtr->getID();
result = -2;
}
}
DOF_Group *dofPtr;
DOF_GrpIter &theDofs = theAnalysisModel->getDOFs();
while((dofPtr = theDofs()) != 0) {
dofPtr->zeroTangent();
dofPtr->addMtoTang(1.0);
if (theEigenSOE->addM(dofPtr->getTangent(0),dofPtr->getID()) < 0) {
opserr << "WARNING DirectIntegrationAnalysis::eigen() -";
opserr << " failed in addM for ID " << dofPtr->getID();
result = -3;
}
}
}
//
// solve for the eigen values & vectors
//
if (theEigenSOE->solve(numMode, generalized) < 0) {
opserr << "WARNING DirectIntegrationAnalysis::eigen() - EigenSOE failed in solve()\n";
return -4;
}
//
// now set the eigenvalues and eigenvectors in the model
//
theAnalysisModel->setNumEigenvectors(numMode);
Vector theEigenvalues(numMode);
for (int i = 1; i <= numMode; i++) {
theEigenvalues[i-1] = theEigenSOE->getEigenvalue(i);
theAnalysisModel->setEigenvector(i, theEigenSOE->getEigenvector(i));
}
theAnalysisModel->setEigenvalues(theEigenvalues);
return 0;
}
int HHTHSFixedNumIter::domainChanged()
{
AnalysisModel *myModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
const Vector &x = theLinSOE->getX();
int size = x.Size();
// if damping factors exist set them in the ele & node of the domain
if (alphaM != 0.0 || betaK != 0.0 || betaKi != 0.0 || betaKc != 0.0)
myModel->setRayleighDampingFactors(alphaM, betaK, betaKi, betaKc);
// create the new Vector objects
if (Ut == 0 || Ut->Size() != size) {
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (Ualpha != 0)
delete Ualpha;
if (Ualphadot != 0)
delete Ualphadot;
if (Ualphadotdot != 0)
delete Ualphadotdot;
if (Utm1 != 0)
delete Utm1;
if (Utm2 != 0)
delete Utm2;
if (scaledDeltaU != 0)
delete scaledDeltaU;
// create the new
Ut = new Vector(size);
Utdot = new Vector(size);
Utdotdot = new Vector(size);
U = new Vector(size);
Udot = new Vector(size);
Udotdot = new Vector(size);
Ualpha = new Vector(size);
Ualphadot = new Vector(size);
Ualphadotdot = new Vector(size);
Utm1 = new Vector(size);
Utm2 = new Vector(size);
scaledDeltaU = new Vector(size);
// check we obtained the new
if (Ut == 0 || Ut->Size() != size ||
Utdot == 0 || Utdot->Size() != size ||
Utdotdot == 0 || Utdotdot->Size() != size ||
U == 0 || U->Size() != size ||
Udot == 0 || Udot->Size() != size ||
Udotdot == 0 || Udotdot->Size() != size ||
Ualpha == 0 || Ualpha->Size() != size ||
Ualphadot == 0 || Ualphadot->Size() != size ||
Ualphadotdot == 0 || Ualphadotdot->Size() != size ||
Utm1 == 0 || Utm1->Size() != size ||
Utm2 == 0 || Utm2->Size() != size ||
scaledDeltaU == 0 || scaledDeltaU->Size() != size) {
opserr << "HHTHSFixedNumIter::domainChanged - ran out of memory\n";
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (Ualpha != 0)
delete Ualpha;
if (Ualphadot != 0)
delete Ualphadot;
if (Ualphadotdot != 0)
delete Ualphadotdot;
if (Utm1 != 0)
delete Utm1;
if (Utm2 != 0)
delete Utm2;
if (scaledDeltaU != 0)
delete scaledDeltaU;
Ut = 0; Utdot = 0; Utdotdot = 0;
U = 0; Udot = 0; Udotdot = 0;
Ualpha = 0; Ualphadot = 0; Ualphadotdot = 0;
Utm1 = 0; Utm2 = 0; scaledDeltaU = 0;
return -1;
}
}
// now go through and populate U, Udot and Udotdot by iterating through
// the DOF_Groups and getting the last committed velocity and accel
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
int i;
const Vector &disp = dofPtr->getCommittedDisp();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Utm1)(loc) = disp(i);
(*Ut)(loc) = disp(i);
(*U)(loc) = disp(i);
}
}
const Vector &vel = dofPtr->getCommittedVel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udot)(loc) = vel(i);
}
}
const Vector &accel = dofPtr->getCommittedAccel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udotdot)(loc) = accel(i);
}
}
}
if (polyOrder == 2)
opserr << "\nWARNING: HHTHSFixedNumIter::domainChanged() - assuming Ut-1 = Ut\n";
else if (polyOrder == 3)
opserr << "\nWARNING: HHTHSFixedNumIter::domainChanged() - assuming Ut-2 = Ut-1 = Ut\n";
return 0;
}
int
DisplacementControl::domainChanged(void)
{
// we first create the Vectors needed
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING DisplacementControl::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
int size = theModel->getNumEqn(); // ask model in case N+1 space
if (deltaUhat == 0 || deltaUhat->Size() != size) { // create new Vector
if (deltaUhat != 0)
delete deltaUhat; // delete the old
deltaUhat = new Vector(size);
if (deltaUhat == 0 || deltaUhat->Size() != size) { // check got it
opserr << "FATAL DisplacementControl::domainChanged() - ran out of memory for";
opserr << " deltaUhat Vector of size " << size << endln;
exit(-1);
}
}
if (deltaUbar == 0 || deltaUbar->Size() != size) { // create new Vector
if (deltaUbar != 0)
delete deltaUbar; // delete the old
deltaUbar = new Vector(size);
if (deltaUbar == 0 || deltaUbar->Size() != size) { // check got it
opserr << "FATAL DisplacementControl::domainChanged() - ran out of memory for";
opserr << " deltaUbar Vector of size " << size << endln;
exit(-1);
}
}
if (deltaU == 0 || deltaU->Size() != size) { // create new Vector
if (deltaU != 0)
delete deltaU; // delete the old
deltaU = new Vector(size);
if (deltaU == 0 || deltaU->Size() != size) { // check got it
opserr << "FATAL DisplacementControl::domainChanged() - ran out of memory for";
opserr << " deltaU Vector of size " << size << endln;
exit(-1);
}
}
if (deltaUstep == 0 || deltaUstep->Size() != size) {
if (deltaUstep != 0)
delete deltaUstep;
deltaUstep = new Vector(size);
if (deltaUstep == 0 || deltaUstep->Size() != size) {
opserr << "FATAL DisplacementControl::domainChanged() - ran out of memory for";
opserr << " deltaUstep Vector of size " << size << endln;
exit(-1);
}
}
if (phat == 0 || phat->Size() != size) {
if (phat != 0)
delete phat;
phat = new Vector(size);
if (phat == 0 || phat->Size() != size) {
opserr << "FATAL DisplacementControl::domainChanged() - ran out of memory for";
opserr << " phat Vector of size " << size << endln;
exit(-1);
}
}
// now we have to determine phat
// do this by incrementing lambda by 1, applying load
// and getting phat from unbalance.
currentLambda = theModel->getCurrentDomainTime();
currentLambda += 1.0;
theModel->applyLoadDomain(currentLambda);
this->formUnbalance(); // NOTE: this assumes unbalance at last was 0
(*phat) = theLinSOE->getB();
currentLambda -= 1.0;
theModel->setCurrentDomainTime(currentLambda);
// check there is a reference load
int haveLoad = 0;
for (int i=0; i<size; i++)
if ( (*phat)(i) != 0.0 ) {
haveLoad = 1;
i = size;
}
if (haveLoad == 0) {
opserr << "WARNING DisplacementControl::domainChanged() - zero reference load";
return -1;
}
// lastly we determine the id of the nodal dof
// EXTRA CODE TO DO SOME ERROR CHECKING REQUIRED
Node *theNodePtr = theDomain->getNode(theNode);
if (theNodePtr == 0) {
opserr << "DisplacementControl::domainChanged - no node\n";
return -1;
}
DOF_Group *theGroup = theNodePtr->getDOF_GroupPtr();
if (theGroup == 0) {
return 0;
}
const ID &theID = theGroup->getID();
theDofID = theID(theDof);
return 0;
}
int
CentralDifferenceNoDamping::domainChanged()
{
AnalysisModel *myModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
const Vector &x = theLinSOE->getX();
int size = x.Size();
// create the new Vector objects
if (U == 0 || U->Size() != size) {
// delete the old
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
// create the new
U = new Vector(size);
Udot = new Vector(size);
Udotdot = new Vector(size);
// cheack we obtained the new
if (U == 0 || U->Size() != size ||
Udot == 0 || Udot->Size() != size ||
Udotdot == 0 || Udotdot->Size() != size) {
opserr << "CentralDifferenceNoDamping::domainChanged - ran out of memory\n";
// delete the old
if (U != 0)
delete U;
if (Udot != 0)
delete U;
if (Udotdot != 0)
delete Udot;
U = 0; Udot = 0; Udotdot = 0;
return -1;
}
}
// now go through and populate U and Udot by iterating through
// the DOF_Groups and getting the last committed velocity and accel
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
int i;
const Vector &disp = dofPtr->getCommittedDisp();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*U)(loc) = disp(i);
}
}
const Vector &vel = dofPtr->getCommittedVel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udot)(loc) = vel(i);
}
}
}
return 0;
}
int CentralDifference::domainChanged()
{
AnalysisModel *myModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
const Vector &x = theLinSOE->getX();
int size = x.Size();
// if damping factors exist set them in the element & node of the domain
if (alphaM != 0.0 || betaK != 0.0 || betaKi != 0.0 || betaKc != 0.0)
myModel->setRayleighDampingFactors(alphaM, betaK, betaKi, betaKc);
// create the new Vector objects
if (Ut == 0 || Ut->Size() != size) {
if (Utm1 != 0)
delete Utm1;
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
// create the new
Utm1 = new Vector(size);
Ut = new Vector(size);
Utdot = new Vector(size);
Utdotdot = new Vector(size);
Udot = new Vector(size);
Udotdot = new Vector(size);
// check we obtained the new
if (Utm1 == 0 || Utm1->Size() != size ||
Ut == 0 || Ut->Size() != size ||
Utdot == 0 || Utdot->Size() != size ||
Utdotdot == 0 || Utdotdot->Size() != size ||
Udot == 0 || Udot->Size() != size ||
Udotdot == 0 || Udotdot->Size() != size) {
opserr << "CentralDifference::domainChanged - ran out of memory\n";
// delete the old
if (Utm1 != 0)
delete Utm1;
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
Utm1 = 0;
Ut = 0; Utdot = 0; Utdotdot = 0;
Udot = 0; Udotdot = 0;
return -1;
}
}
// now go through and populate U, Udot and Udotdot by iterating through
// the DOF_Groups and getting the last committed velocity and accel
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
int i;
const Vector &disp = dofPtr->getCommittedDisp();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Utm1)(loc) = disp(i);
(*Ut)(loc) = disp(i);
}
}
const Vector &vel = dofPtr->getCommittedVel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udot)(loc) = vel(i);
}
}
const Vector &accel = dofPtr->getCommittedAccel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udotdot)(loc) = accel(i);
}
}
}
opserr << "WARNING: CentralDifference::domainChanged() - assuming Ut-1 = Ut\n";
return 0;
}
int
TransformationFE::setID(void)
{
// determine number of DOF
numTransformedDOF = 0;
for (int ii=0; ii<numGroups; ii++) {
DOF_Group *dofPtr = theDOFs[ii];
numTransformedDOF += dofPtr->getNumDOF();
}
// create an ID to hold the array, cannot use existing as
// may be different size
if (modID != 0)
delete modID;
modID = 0;
modID = new ID(numTransformedDOF);
if (modID == 0 || modID->Size() == 0) {
opserr << "TransformationFE::setID() ";
opserr << " ran out of memory for ID of size :";
opserr << numTransformedDOF << endln;
exit(-1);
}
// fill in the ID
int current = 0;
for (int i=0; i<numGroups; i++) {
DOF_Group *dofPtr = theDOFs[i];
const ID &theDOFid = dofPtr->getID();
for (int j=0; j<theDOFid.Size(); j++)
if (current < numTransformedDOF)
(*modID)(current++) = theDOFid(j);
else {
opserr << "WARNING TransformationFE::setID() - numDOF and";
opserr << " number of dof at the DOF_Groups\n";
return -3;
}
}
// set the pointers to the modified tangent matrix and residual vector
if (numTransformedDOF <= MAX_NUM_DOF) {
// use class wide objects
if (modVectors[numTransformedDOF] == 0) {
modVectors[numTransformedDOF] = new Vector(numTransformedDOF);
modMatrices[numTransformedDOF] = new Matrix(numTransformedDOF,numTransformedDOF);
modResidual = modVectors[numTransformedDOF];
modTangent = modMatrices[numTransformedDOF];
if (modResidual == 0 || modResidual->Size() != numTransformedDOF ||
modTangent == 0 || modTangent->noCols() != numTransformedDOF) {
opserr << "TransformationFE::setID() ";
opserr << " ran out of memory for vector/Matrix of size :";
opserr << numTransformedDOF << endln;
exit(-1);
}
} else {
modResidual = modVectors[numTransformedDOF];
modTangent = modMatrices[numTransformedDOF];
}
} else {
// create matrices and vectors for each object instance
modResidual = new Vector(numTransformedDOF);
modTangent = new Matrix(numTransformedDOF, numTransformedDOF);
if (modResidual == 0 || modResidual->Size() ==0 ||
modTangent ==0 || modTangent->noRows() ==0) {
opserr << "TransformationFE::setID() ";
opserr << " ran out of memory for vector/Matrix of size :";
opserr << numTransformedDOF << endln;
exit(-1);
}
}
return 0;
}
Graph &
AnalysisModel::getDOFGraph(void)
{
if (myDOFGraph == 0) {
int numVertex = this->getNumDOF_Groups();
// myDOFGraph = new Graph(numVertex);
MapOfTaggedObjects *graphStorage = new MapOfTaggedObjects();
myDOFGraph = new Graph(*graphStorage);
//
// create a vertex for each dof
//
DOF_Group *dofPtr =0;
DOF_GrpIter &theDOFs = this->getDOFs();
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int size = id.Size();
for (int i=0; i<size; i++) {
int dofTag = id(i);
if (dofTag >= START_EQN_NUM) {
Vertex *vertexPtr = myDOFGraph->getVertexPtr(dofTag);
if (vertexPtr == 0) {
Vertex *vertexPtr = new Vertex(dofTag, dofTag);
if (vertexPtr == 0) {
opserr << "WARNING AnalysisModel::getDOFGraph";
opserr << " - Not Enough Memory to create " << i+1 << "th Vertex\n";
return *myDOFGraph;
}
if (myDOFGraph->addVertex(vertexPtr, false) == false) {
opserr << "WARNING AnalysisModel::getDOFGraph - error adding vertex\n";
return *myDOFGraph;
}
}
}
}
}
// now add the edges, by looping over the FE_elements, getting their
// IDs and adding edges between DOFs for equation numbers >= START_EQN_NUM
FE_Element *elePtr =0;
FE_EleIter &eleIter = this->getFEs();
int cnt = 0;
while((elePtr = eleIter()) != 0) {
const ID &id = elePtr->getID();
cnt++;
int size = id.Size();
for (int i=0; i<size; i++) {
int eqn1 = id(i);
// if eqnNum of DOF is a valid eqn number add an edge
// to all other DOFs with valid eqn numbers.
if (eqn1 >=START_EQN_NUM) {
for (int j=i+1; j<size; j++) {
int eqn2 = id(j);
if (eqn2 >=START_EQN_NUM)
myDOFGraph->addEdge(eqn1-START_EQN_NUM+START_VERTEX_NUM,
eqn2-START_EQN_NUM+START_VERTEX_NUM);
}
}
}
}
}
return *myDOFGraph;
}
int
IncrementalIntegrator::setupModal(const Vector *modalDampingValues)
{
int numModes = modalDampingValues->Size();
const Vector &eigenvalues = theAnalysisModel->getEigenvalues();
int numEigen = eigenvalues.Size();
if (numEigen < numModes)
numModes = numEigen;
int numDOF = theSOE->getNumEqn();
if (eigenValues == 0 || *eigenValues != eigenvalues) {
if (eigenValues != 0)
delete eigenValues;
if (eigenVectors != 0)
delete [] eigenVectors;
if (dampingForces != 0)
delete dampingForces;
if (mV != 0)
delete mV;
if (tmpV1 != 0)
delete tmpV1;
if (tmpV2 != 0)
delete tmpV2;
eigenValues = new Vector(eigenvalues);
dampingForces = new Vector(numDOF);
eigenVectors = new double[numDOF*numModes];
mV = new Vector(numDOF);
tmpV1 = new Vector(numDOF);
tmpV2 = new Vector(numDOF);
DOF_GrpIter &theDOFs2 = theAnalysisModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs2()) != 0) {
const Matrix &dofEigenvectors =dofPtr->getEigenvectors();
const ID &dofID = dofPtr->getID();
for (int j=0; j<numModes; j++) {
for (int i=0; i<dofID.Size(); i++) {
int id = dofID(i);
if (id >= 0)
eigenVectors[j*numDOF + id] = dofEigenvectors(i,j);
}
}
}
double *eigenVectors2 = new double[numDOF*numModes];
for (int i=0; i<numModes; i++) {
double *eigenVectorI = &eigenVectors[numDOF*i];
double *mEigenVectorI = &eigenVectors2[numDOF*i];
Vector v1(eigenVectorI,numDOF);
Vector v2(mEigenVectorI,numDOF);
this->doMv(v1, v2);
}
eigenVectors = eigenVectors2;
}
return 0;
}
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
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 XC::ParallelNumberer::numberDOF(ID &lastDOFs)
{
int result= 0;
// get a pointer to the model & check its not null
AnalysisModel *theModel= this->getAnalysisModelPtr();
Domain *theDomain= 0;
if(theModel != 0) theDomain= theModel->getDomainPtr();
if(theModel == 0 || theDomain == 0) {
std::cerr << "WARNING ParallelNumberer::numberDOF(int) -";
std::cerr << " - no AnalysisModel.\n";
return -1;
}
Graph &theGraph= theModel->getDOFGroupGraph();
// if subdomain, collect graph, send it off, get
// ID back containing dof tags & start id numbers.
if(processID != 0)
{
CommParameters cp(0,*theChannels[0]);
int numVertex= theGraph.getNumVertex();
cp.sendMovable(theGraph,DistributedObj::getDbTagData(),CommMetaData(5));
ID theID(2*numVertex);
cp.receiveID(theID,DistributedObj::getDbTagData(),CommMetaData(6));
for(int i=0; i<numVertex; i += 2) {
int dofTag= theID(i);
int startID= theID(i+1);
DOF_Group *dofPtr;
dofPtr= theModel->getDOF_GroupPtr(dofTag);
if(dofPtr == 0) {
std::cerr << "WARNING XC::ParallelNumberer::numberDOF - ";
std::cerr << "DOF_Group " << dofTag << "not in XC::AnalysisModel!\n";
result= -4;
} else {
const ID &theID= dofPtr->getID();
int idSize= theID.Size();
for(int j=0; j<idSize; j++)
if(theID(j) == -2) dofPtr->setID(j, startID++);
}
}
}
// if XC::main domain, collect graphs from all subdomains,
// merge into 1, number this one, send to subdomains the
// id containing dof tags & start id's.
else {
// determine original vertex and ref tags
int numVertex= theGraph.getNumVertex();
ID vertexTags(numVertex);
ID vertexRefs(numVertex);
Vertex *vertexPtr;
int loc= 0;
VertexIter &theVertices= theGraph.getVertices();
while ((vertexPtr= theVertices()) != 0) {
vertexTags[loc]= vertexPtr->getTag();
vertexRefs[loc]= vertexPtr->getRef();
loc++;
}
const int numChannels= theChannels.size();
std::vector<ID> theSubdomainIDs(numChannels);
FEM_ObjectBroker theBroker;
// merge all subdomain graphs
for(int j=0; j<numChannels; j++)
{
CommParameters cp(0,*theChannels[j]);
Graph theSubGraph;
cp. receiveMovable(theSubGraph,DistributedObj::getDbTagData(),CommMetaData(6));
theSubdomainIDs[j]= ID(theSubGraph.getNumVertex()*2);
this->mergeSubGraph(theGraph, theSubGraph, vertexTags, vertexRefs, theSubdomainIDs[j]);
}
// number the merged graph
// result= this->XC::DOF_Numberer::number(theGraph);
// send results of numbered back to subdomains
for(int k=0; k<numChannels; k++)
{
Channel *theChannel= theChannels[k];
// this->determineSubIDs
theChannel->sendID(0, 0, theSubdomainIDs[k]);
}
}
return result;
}
int
HHT1::domainChanged()
{
AnalysisModel *myModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
const Vector &x = theLinSOE->getX();
int size = x.Size();
// if damping factors exist set them in the ele & node of the domain
if (alphaM != 0.0 || betaK != 0.0 || betaKi != 0.0 || betaKc != 0.0)
myModel->setRayleighDampingFactors(alphaM, betaK, betaKi, betaKc);
// create the new Vector objects
if (Ut == 0 || Ut->Size() != size) {
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (Ualpha != 0)
delete Ualpha;
if (Udotalpha != 0)
delete Udotalpha;
// create the new
Ut = new Vector(size);
Utdot = new Vector(size);
Utdotdot = new Vector(size);
U = new Vector(size);
Udot = new Vector(size);
Udotdot = new Vector(size);
Ualpha = new Vector(size);
Udotalpha = new Vector(size);
// check we obtained the new
if (Ut == 0 || Ut->Size() != size ||
Utdot == 0 || Utdot->Size() != size ||
Utdotdot == 0 || Utdotdot->Size() != size ||
U == 0 || U->Size() != size ||
Udot == 0 || Udot->Size() != size ||
Udotdot == 0 || Udotdot->Size() != size ||
Ualpha == 0 || Ualpha->Size() != size ||
Udotalpha == 0 || Udotalpha->Size() != size) {
opserr << "HHT1::domainChanged - ran out of memory\n";
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (Ualpha != 0)
delete Ualpha;
if (Udotalpha != 0)
delete Udotalpha;
Ut = 0; Utdot = 0; Utdotdot = 0;
U = 0; Udot = 0; Udotdot = 0; Udotalpha=0; Ualpha =0;
return -1;
}
}
// now go through and populate U, Udot and Udotdot by iterating through
// the DOF_Groups and getting the last committed velocity and accel
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
int i;
const Vector &disp = dofPtr->getCommittedDisp();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*U)(loc) = disp(i);
}
}
const Vector &vel = dofPtr->getCommittedVel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udot)(loc) = vel(i);
}
}
const Vector &accel = dofPtr->getCommittedAccel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udotdot)(loc) = accel(i);
}
}
/** NOTE WE CAN't DO TOGETHER BECAUSE DOF_GROUPS USING SINGLE VECTOR ******
for (int i=0; i < id.Size(); i++) {
int loc = id(i);
if (loc >= 0) {
(*U)(loc) = disp(i);
(*Udot)(loc) = vel(i);
(*Udotdot)(loc) = accel(i);
}
}
*******************************************************************************/
}
return 0;
}
void
ArpackSolver::myMv(int n, double *v, double *result)
{
Vector x(v, n);
Vector y(result,n);
bool mDiagonal = theArpackSOE->mDiagonal;
if (mDiagonal == true) {
int Msize = theArpackSOE->Msize;
double *M = theArpackSOE->M;
/* for output
DataFileStream dataStream("M.txt");
dataStream.open();
for (int i=0; i<n; i++)
dataStream << M[i] << endln;
dataStream.close();
*/
if (n <= Msize) {
for (int i=0; i<n; i++)
result[i] = M[i]*v[i];
} else {
opserr << "ArpackSolver::myMv() n > Msize!\n";
return;
}
} else {
y.Zero();
AnalysisModel *theAnalysisModel = theArpackSOE->theModel;
// loop over the FE_Elements
FE_Element *elePtr;
FE_EleIter &theEles = theAnalysisModel->getFEs();
while((elePtr = theEles()) != 0) {
const Vector &b = elePtr->getM_Force(x, 1.0);
y.Assemble(b, elePtr->getID(), 1.0);
}
// loop over the DOF_Groups
DOF_Group *dofPtr;
DOF_GrpIter &theDofs = theAnalysisModel->getDOFs();
while ((dofPtr = theDofs()) != 0) {
const Vector &a = dofPtr->getM_Force(x,1.0);
y.Assemble(a, dofPtr->getID(), 1.0);
}
}
// if paallel we have to merge the results
int processID = theArpackSOE->processID;
if (processID != -1) {
Channel **theChannels = theArpackSOE->theChannels;
int numChannels = theArpackSOE->numChannels;
if (processID != 0) {
theChannels[0]->sendVector(0, 0, y);
theChannels[0]->recvVector(0, 0, y);
} else {
Vector other(workArea, n);
// recv contribution from remote & add
for (int i=0; i<numChannels; i++) {
theChannels[i]->recvVector(0,0,other);
y += other;
}
// send result back
for (int i=0; i<numChannels; i++) {
theChannels[i]->sendVector(0,0,y);
}
}
}
}
int
PFEMIntegrator::formEleResidual(FE_Element *theEle)
{
if (sensitivityFlag == 0) { // NO SENSITIVITY ANALYSIS
this->TransientIntegrator::formEleResidual(theEle);
}
else { // (ASSEMBLE ALL TERMS)
theEle->zeroResidual();
// Compute the time-stepping parameters on the form
// udotdot = 1/dt*vn+1 - 1/dt*vn
// u = un + dt*vn+1
// Obtain sensitivity vectors from previous step
dVn.resize(U->Size()); dVn.Zero();
Vector dUn(U->Size());
AnalysisModel *myModel = this->getAnalysisModel();
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr = 0;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
const Vector &dispSens = dofPtr->getDispSensitivity(gradNumber);
for (int i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
dUn(loc) = dispSens(i);
}
}
const Vector &velSens = dofPtr->getVelSensitivity(gradNumber);
for (int i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
dVn(loc) = velSens(i);
}
}
}
// Now we're ready to make calls to the FE Element:
// The term -dPint/dh|u fixed
theEle->addResistingForceSensitivity(gradNumber);
// The term -dM/dh*acc
theEle->addM_ForceSensitivity(gradNumber, *Udotdot, -1.0);
// The term -M*(-1/dt*dvn)
theEle->addM_Force(dVn, c3);
// The term -K*(dun)
theEle->addK_Force(dUn, -1.0);
// The term -dC/dh*vel
theEle->addD_ForceSensitivity(gradNumber, *Udot,-1.0);
}
return 0;
}
// void setID(int index, int value);
// Method to set the correMPonding index of the ID to value.
int
PenaltyMP_FE::setID(void)
{
int result = 0;
// first determine the IDs in myID for those DOFs marked
// as constrained DOFs, this is obtained from the DOF_Group
// associated with the constrained node
DOF_Group *theConstrainedNodesDOFs = theConstrainedNode->getDOF_GroupPtr();
if (theConstrainedNodesDOFs == 0) {
opserr << "WARNING PenaltyMP_FE::setID(void)";
opserr << " - no DOF_Group with Constrained Node\n";
return -2;
}
const ID &constrainedDOFs = theMP->getConstrainedDOFs();
const ID &theConstrainedNodesID = theConstrainedNodesDOFs->getID();
int size1 = constrainedDOFs.Size();
for (int i=0; i<size1; i++) {
int constrained = constrainedDOFs(i);
if (constrained < 0 ||
constrained >= theConstrainedNode->getNumberDOF()) {
opserr << "WARNING PenaltyMP_FE::setID(void) - unknown DOF ";
opserr << constrained << " at Node\n";
myID(i) = -1; // modify so nothing will be added to equations
result = -3;
}
else {
if (constrained >= theConstrainedNodesID.Size()) {
opserr << "WARNING PenaltyMP_FE::setID(void) - ";
opserr << " Nodes DOF_Group too small\n";
myID(i) = -1; // modify so nothing will be added to equations
result = -4;
}
else
myID(i) = theConstrainedNodesID(constrained);
}
}
// now determine the IDs for the retained dof's
DOF_Group *theRetainedNodesDOFs = theRetainedNode->getDOF_GroupPtr();
if (theRetainedNodesDOFs == 0) {
opserr << "WARNING PenaltyMP_FE::setID(void)";
opserr << " - no DOF_Group with Retained Node\n";
return -2;
}
const ID &RetainedDOFs = theMP->getRetainedDOFs();
const ID &theRetainedNodesID = theRetainedNodesDOFs->getID();
int size2 = RetainedDOFs.Size();
for (int j=0; j<size2; j++) {
int retained = RetainedDOFs(j);
if (retained < 0 || retained >= theRetainedNode->getNumberDOF()) {
opserr << "WARNING PenaltyMP_FE::setID(void) - unknown DOF ";
opserr << retained << " at Node\n";
myID(j+size1) = -1; // modify so nothing will be added
result = -3;
}
else {
if (retained >= theRetainedNodesID.Size()) {
opserr << "WARNING PenaltyMP_FE::setID(void) - ";
opserr << " Nodes DOF_Group too small\n";
myID(j+size1) = -1; // modify so nothing will be added
result = -4;
}
else
myID(j+size1) = theRetainedNodesID(retained);
}
}
myDOF_Groups(0) = theConstrainedNodesDOFs->getTag();
myDOF_Groups(1) = theRetainedNodesDOFs->getTag();
return result;
}
int
PlainNumberer::numberDOF(int lastDOF)
{
int eqnNumber = 0; // start equation number = 0
// get a pointer to the model & check its not null
AnalysisModel *theModel = this->getAnalysisModelPtr();
Domain *theDomain = 0;
if (theModel != 0) theDomain = theModel->getDomainPtr();
if (theModel == 0 || theDomain == 0) {
opserr << "WARNING PlainNumberer::numberDOF(int) -";
opserr << " - no AnalysisModel - has setLinks() been invoked?\n";
return -1;
}
if (lastDOF != -1) {
opserr << "WARNING PlainNumberer::numberDOF(int lastDOF):";
opserr << " does not use the lastDOF as requested\n";
}
// iterate throgh the DOFs first time setting -2 values
DOF_GrpIter &theDOFs = theModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &theID = dofPtr->getID();
for (int i=0; i<theID.Size(); i++)
if (theID(i) == -2)
dofPtr->setID(i,eqnNumber++);
}
// iterate throgh the DOFs second time setting -3 values
DOF_GrpIter &moreDOFs = theModel->getDOFs();
while ((dofPtr = moreDOFs()) != 0) {
const ID &theID = dofPtr->getID();
for (int i=0; i<theID.Size(); i++)
if (theID(i) == -3) dofPtr->setID(i,eqnNumber++);
}
// iterate through the DOFs one last time setting any -4 values
DOF_GrpIter &tDOFs = theModel->getDOFs();
while ((dofPtr = tDOFs()) != 0) {
const ID &theID = dofPtr->getID();
int have4s = 0;
for (int i=0; i<theID.Size(); i++)
if (theID(i) == -4) have4s = 1;
if (have4s == 1) {
int nodeID = dofPtr->getNodeTag();
// loop through the MP_Constraints to see if any of the
// DOFs are constrained, note constraint matrix must be diagonal
// with 1's on the diagonal
MP_ConstraintIter &theMPs = theDomain->getMPs();
MP_Constraint *mpPtr;
while ((mpPtr = theMPs()) != 0 ) {
// note keep looping over all in case multiple constraints
// are used to constrain a node -- can't assume intelli user
if (mpPtr->getNodeConstrained() == nodeID) {
int nodeRetained = mpPtr->getNodeRetained();
Node *nodeRetainedPtr = theDomain->getNode(nodeRetained);
DOF_Group *retainedDOF = nodeRetainedPtr->getDOF_GroupPtr();
const ID&retainedDOFIDs = retainedDOF->getID();
const ID&constrainedDOFs = mpPtr->getConstrainedDOFs();
const ID&retainedDOFs = mpPtr->getRetainedDOFs();
for (int i=0; i<constrainedDOFs.Size(); i++) {
int dofC = constrainedDOFs(i);
int dofR = retainedDOFs(i);
int dofID = retainedDOFIDs(dofR);
dofPtr->setID(dofC, dofID);
}
}
}
}
}
eqnNumber--;
int numEqn = eqnNumber - START_EQN_NUMBER +1;
// iterate through the FE_Element getting them to set their IDs
FE_EleIter &theEle = theModel->getFEs();
FE_Element *elePtr;
while ((elePtr = theEle()) != 0)
elePtr->setID();
// set the numOfEquation in the Model
theModel->setNumEqn(numEqn);
return numEqn;
}
int CollocationHSIncrReduct::domainChanged()
{
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
const Vector &x = theLinSOE->getX();
int size = x.Size();
// create the new Vector objects
if (Ut == 0 || Ut->Size() != size) {
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (scaledDeltaU != 0)
delete scaledDeltaU;
// create the new
Ut = new Vector(size);
Utdot = new Vector(size);
Utdotdot = new Vector(size);
U = new Vector(size);
Udot = new Vector(size);
Udotdot = new Vector(size);
scaledDeltaU = new Vector(size);
// check we obtained the new
if (Ut == 0 || Ut->Size() != size ||
Utdot == 0 || Utdot->Size() != size ||
Utdotdot == 0 || Utdotdot->Size() != size ||
U == 0 || U->Size() != size ||
Udot == 0 || Udot->Size() != size ||
Udotdot == 0 || Udotdot->Size() != size ||
scaledDeltaU == 0 || scaledDeltaU->Size() != size) {
opserr << "CollocationHSIncrReduct::domainChanged() - ran out of memory\n";
// delete the old
if (Ut != 0)
delete Ut;
if (Utdot != 0)
delete Utdot;
if (Utdotdot != 0)
delete Utdotdot;
if (U != 0)
delete U;
if (Udot != 0)
delete Udot;
if (Udotdot != 0)
delete Udotdot;
if (scaledDeltaU != 0)
delete scaledDeltaU;
Ut = 0; Utdot = 0; Utdotdot = 0;
U = 0; Udot = 0; Udotdot = 0;
scaledDeltaU = 0;
return -1;
}
}
// now go through and populate U, Udot and Udotdot by iterating through
// the DOF_Groups and getting the last committed velocity and accel
DOF_GrpIter &theDOFs = theModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
int i;
const Vector &disp = dofPtr->getCommittedDisp();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*U)(loc) = disp(i);
}
}
const Vector &vel = dofPtr->getCommittedVel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udot)(loc) = vel(i);
}
}
const Vector &accel = dofPtr->getCommittedAccel();
for (i=0; i < idSize; i++) {
int loc = id(i);
if (loc >= 0) {
(*Udotdot)(loc) = accel(i);
}
}
}
return 0;
}
int
NewmarkSensitivityIntegrator::saveSensitivity(const Vector & vNew,int gradNum,int numGrads)
{
// Compute Newmark parameters in general notation
double a1 = c3;
double a2 = -c3;
double a3 = -c2/gamma;
double a4 = 1.0 - 1.0/(2.0*beta);
double a5 = c2;
double a6 = -c2;
double a7 = 1.0 - gamma/beta;
double dt = gamma/(beta*c2);
double a8 = dt*(1.0 - gamma/(2.0*beta));
// Recover sensitivity results from previous step
int vectorSize = U->Size();
Vector V(vectorSize);
Vector Vdot(vectorSize);
Vector Vdotdot(vectorSize);
int i, loc;
AnalysisModel *myModel = this->getAnalysisModel();
DOF_GrpIter &theDOFs = myModel->getDOFs();
DOF_Group *dofPtr;
while ((dofPtr = theDOFs()) != 0) {
const ID &id = dofPtr->getID();
int idSize = id.Size();
const Vector &dispSens = dofPtr->getDispSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
V(loc) = dispSens(i);
}
}
const Vector &velSens = dofPtr->getVelSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
Vdot(loc) = velSens(i);
}
}
const Vector &accelSens = dofPtr->getAccSensitivity(gradNumber);
for (i=0; i < idSize; i++) {
loc = id(i);
if (loc >= 0) {
Vdotdot(loc) = accelSens(i);
}
}
}
// Compute new acceleration and velocity vectors:
Vector vdotNew(vectorSize);
Vector vdotdotNew(vectorSize);
//(*vdotdotNewPtr) = vNew*a1 + V*a2 + Vdot*a3 + Vdotdot*a4;
vdotdotNew.addVector(0.0, vNew, a1);
vdotdotNew.addVector(1.0, V, a2);
vdotdotNew.addVector(1.0, Vdot, a3);
vdotdotNew.addVector(1.0, Vdotdot, a4);
//(*vdotNewPtr) = vNew*a5 + V*a6 + Vdot*a7 + Vdotdot*a8;
vdotNew.addVector(0.0, vNew, a5);
vdotNew.addVector(1.0, V, a6);
vdotNew.addVector(1.0, Vdot, a7);
vdotNew.addVector(1.0, Vdotdot, a8);
// Now we can save vNew, vdotNew and vdotdotNew
DOF_GrpIter &theDOFGrps = myModel->getDOFs();
DOF_Group *dofPtr1;
while ( (dofPtr1 = theDOFGrps() ) != 0) {
dofPtr1->saveSensitivity(vNew,vdotNew,vdotdotNew,gradNum,numGrads);
}
return 0;
}
