// 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
DOF_Group::getNumFreeDOF(void) const
{
int numFreeDOF = numDOF;
for (int i=0; i<numDOF; i++)
if (myID(i) == -1 || myID(i) == -4)
numFreeDOF--;
return numFreeDOF;
}
void
DOF_Group::incrNodeDisp(const Vector &u)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeDisp: 0 Node Pointer\n";
exit(-1);
}
Vector &disp = *unbalance;;
if (disp.Size() == 0) {
opserr << "DOF_Group::setNodeIncrDisp - out of space\n";
return;
}
int i;
// get disp for my dof out of vector u
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
disp(i) = u(loc);
else disp(i) = 0.0;
}
myNode->incrTrialDisp(disp);
}
void
DOF_Group::addD_ForceSensitivity(const Vector &Udot, double fact)
{
if (myNode == 0) {
opserr << "DOF_Group::addD_ForceSensitivity() - no Node associated";
opserr << " subclass should not call this method \n";
return;
}
Vector vel(numDOF);
// get velocity for the unconstrained dof
for (int i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
vel(i) = Udot(loc);
else vel(i) = 0.0;
}
if (unbalance->addMatrixVector(1.0, myNode->getDampSensitivity(), vel, fact) < 0) {
opserr << "DOF_Group::addD_ForceSensitivity() ";
opserr << " invoking addMatrixVector() on the unbalance failed\n";
}
else {
}
}
const Vector &
DOF_Group::getM_Force(const Vector &Udotdot, double fact)
{
if (myNode == 0) {
opserr << "DOF_Group::getM_Force() - no Node associated";
opserr << " subclass should not call this method \n";
return *unbalance;
}
Vector accel(numDOF);
// get accel for the unconstrained dof
for (int i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
accel(i) = Udotdot(loc);
else accel(i) = 0.0;
}
if (unbalance->addMatrixVector(0.0, myNode->getMass(), accel, fact) < 0) {
opserr << "DOF_Group::getM_Force() ";
opserr << " invoking addMatrixVector() on the unbalance failed\n";
}
return *unbalance;
}
// The analyzeSubtree() method is called for every defining function declaration in the AST. Its second argument is the
// inherited attribute computed for this node by the pre-traversal, the value it returns becomes the synthesized
// attribute used by the post-traversal.
std::string analyzeSubtree(SgFunctionDeclaration *funcDecl, int depth)
{
std::string funcName = funcDecl->get_name().str();
std::stringstream s;
s << "process " << myID() << ": at depth " << depth << ": function " << funcName;
return s.str();
}
int
DOF_Group::getNumConstrainedDOF(void) const
{
int numConstr = 0;
for (int i=0; i<numDOF; i++)
if (myID(i) < 0)
numConstr++;
return numConstr;
}
void
DOF_Group::setID(int index, int value)
{
if ((index >= 0) && (index < numDOF))
myID(index) = value;
else {
opserr << "WARNING DOF_Group::setID - invalid location ";
opserr << index << " in ID of size " << numDOF << endln;
}
}
const Vector &
LagrangeSP_FE::getTangForce(const Vector &disp, double fact)
{
double constraint = theSP->getValue();
int constrainedID = myID(1);
if (constrainedID < 0 || constrainedID >= disp.Size()) {
opserr << "WARNING LagrangeSP_FE::getTangForce() - ";
opserr << " constrained DOF " << constrainedID << " outside disp\n";
(*resid)(1) = constraint*alpha;
return *resid;
}
(*resid)(1) = disp(constrainedID);
return *resid;
}
int
DOF_Group::saveAccSensitivity(const Vector &v, int gradNum, int numGrads)
{
Vector &dudh = *unbalance;
for (int i = 0; i < numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
dudh(i) = v(loc);
else
dudh(i) = 0.0;
}
return myNode->saveAccelSensitivity(dudh, gradNum, numGrads);
}
void
DOF_Group::setEigenvector(int mode, const Vector &theVector)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeAccel: 0 Node Pointer\n";
exit(-1);
}
Vector &eigenvector = *unbalance;
int i;
// get disp for the unconstrained dof
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
eigenvector(i) = theVector(loc);
else eigenvector(i) = 0.0;
}
myNode->setEigenvector(mode, eigenvector);
}
void
DOF_Group::incrNodeAccel(const Vector &udotdot)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeAccel: 0 Node Pointer\n";
exit(-1);
}
Vector &accel = *unbalance;
int i;
// get disp for the unconstrained dof
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
accel(i) = udotdot(loc);
else accel(i) = 0.0;
}
myNode->incrTrialAccel(accel);
}
void
DOF_Group::incrNodeVel(const Vector &udot)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeVel: 0 Node Pointer\n";
exit(-1);
}
Vector &vel = *unbalance;
int i;
// get vel for my dof out of vector udot
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
vel(i) = udot(loc); // -1 for dof labelled 1 through ndof
else vel(i) = 0.0;
}
myNode->incrTrialVel(vel);
}
void
DOF_Group::setNodeDisp(const Vector &u)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeDisp: no associated Node\n";
return;
}
Vector &disp = *unbalance;
disp = myNode->getTrialDisp();
int i;
// get disp for my dof out of vector u
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
disp(i) = u(loc);
}
myNode->setTrialDisp(disp);
}
void
DOF_Group::setNodeAccel(const Vector &udotdot)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeAccel: 0 Node Pointer\n";
return;
}
Vector &accel = *unbalance;;
accel = myNode->getTrialAccel();
int i;
// get disp for the unconstrained dof
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
accel(i) = udotdot(loc);
}
myNode->setTrialAccel(accel);
}
void
DOF_Group::setNodeVel(const Vector &udot)
{
if (myNode == 0) {
opserr << "DOF_Group::setNodeVel: 0 Node Pointer\n";
return;
}
Vector &vel = *unbalance;
vel = myNode->getTrialVel();
int i;
// get vel for my dof out of vector udot
for (i=0; i<numDOF; i++) {
int loc = myID(i);
if (loc >= 0)
vel(i) = udot(loc);
}
myNode->setTrialVel(vel);
}
// 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;
}
DOF_Group::DOF_Group(int tag, Node *node)
:TaggedObject(tag),
unbalance(0), tangent(0), myNode(node),
myID(node->getNumberDOF()),
numDOF(node->getNumberDOF())
{
// get number of DOF & verify valid
int numDOF = node->getNumberDOF();
if (numDOF <= 0) {
opserr << "DOF_Group::DOF_Group(Node *) ";
opserr << " node must have at least 1 dof " << *node;
exit(-1);
}
// check the ID created is of appropriate size
if (myID.Size() != numDOF) {
opserr << "DOF_Group::DOF_Group(Node *) ";
opserr << " ran out of memory creating ID for node " << *node;
exit(-1);
}
// initially set all the IDs to be -2
for (int i=0; i<numDOF; i++)
myID(i) = -2;
// if this is the first DOF_Group we now
// create the arrays used to store pointers to class wide
// matrix and vector objects used to return tangent and residual
if (numDOFs == 0) {
theMatrices = new Matrix *[MAX_NUM_DOF+1];
theVectors = new Vector *[MAX_NUM_DOF+1];
if (theMatrices == 0 || theVectors == 0) {
opserr << "DOF_Group::DOF_Group(Node *) ";
opserr << " ran out of memory";
}
for (int i=0; i<MAX_NUM_DOF; i++) {
theMatrices[i] = 0;
theVectors[i] = 0;
}
}
// set the pointers for the tangent and residual
if (numDOF <= MAX_NUM_DOF) {
// use class wide objects
if (theVectors[numDOF] == 0) {
// have to create matrix and vector of size as none yet created
theVectors[numDOF] = new Vector(numDOF);
theMatrices[numDOF] = new Matrix(numDOF,numDOF);
unbalance = theVectors[numDOF];
tangent = theMatrices[numDOF];
if (unbalance == 0 || unbalance->Size() != numDOF ||
tangent == 0 || tangent->noCols() != numDOF) {
opserr << "DOF_Group::DOF_Group(Node *) ";
opserr << " ran out of memory for vector/Matrix of size :";
opserr << numDOF << endln;
exit(-1);
}
} else {
unbalance = theVectors[numDOF];
tangent = theMatrices[numDOF];
}
} else {
// create matrices and vectors for each object instance
unbalance = new Vector(numDOF);
tangent = new Matrix(numDOF, numDOF);
if (unbalance == 0 || unbalance->Size() ==0 ||
tangent ==0 || tangent->noRows() ==0) {
opserr << "DOF_Group::DOF_Group(Node *) ";
opserr << " ran out of memory for vector/Matrix of size :";
opserr << numDOF << endln;
exit(-1);
}
}
numDOFs++;
}
