int XC::DriftRecorder::initialize(void)
{
initializationDone = true; // still might fail but don't want back in again
//
// clean up old memory
//
if(!theNodes.empty())
theNodes.clear();
free_nodes();
//
// check valid node ID's
//
if(!ndI || !ndJ)
{
std::cerr << "XC::DriftRecorder::initialize() - no nodal id's set\n";
return -1;
}
const int ndIsize= ndI->Size();
const int ndJsize= ndJ->Size();
if(ndIsize == 0)
{
std::cerr << "XC::DriftRecorder::initialize() - no nodal id's set\n";
return -1;
}
if(ndIsize != ndJsize)
{
std::cerr << "XC::DriftRecorder::initialize() - error node arrays differ in size"
<< " (" << ndIsize << "!=" << ndJsize << "),\n";
return -2;
}
//
// lets loop through & determine number of valid nodes
//
numNodes = 0;
for(int i=0; i<ndIsize; i++)
{
int ni = (*ndI)(i);
int nj = (*ndJ)(i);
Node *nodeI = theDomain->getNode(ni);
if(!nodeI)
std::cerr << getClassName() << __FUNCTION__
<< "; node identified by: "
<< ni << " not found." << std::endl;
Node *nodeJ = theDomain->getNode(nj);
if(!nodeJ)
std::cerr << getClassName() << __FUNCTION__
<< "; node identified by: "
<< nj << " not found." << std::endl;
if(nodeI && nodeJ )
{
const Vector &crdI = nodeI->getCrds();
const Vector &crdJ = nodeJ->getCrds();
if(crdI.Size() > perpDirn && crdJ.Size() > perpDirn)
if(crdI(perpDirn) != crdJ(perpDirn))
numNodes++;
}
}
if(numNodes == 0)
{
std::cerr << "XC::DriftRecorder::initialize() - no valid nodes or perpendicular direction\n";
return 0;
}
//
// allocate memory
//
int timeOffset = 0;
if(echoTimeFlag == true)
timeOffset = 1;
alloc_nodes(numNodes,timeOffset);
//
// set node pointers and determine one over L
//
int counter = 0;
int counterI = 0;
int counterJ = 1;
for(int j=0; j<ndIsize; j++)
{
int ni = (*ndI)(j);
int nj = (*ndJ)(j);
Node *nodeI= theDomain->getNode(ni);
Node *nodeJ= theDomain->getNode(nj);
if(nodeI != 0 && nodeJ != 0)
{
const XC::Vector &crdI = nodeI->getCrds();
const XC::Vector &crdJ = nodeJ->getCrds();
if(crdI.Size() > perpDirn && crdJ.Size() > perpDirn)
if(crdI(perpDirn) != crdJ(perpDirn))
{
oneOverL(counter) = 1.0/fabs(crdJ(perpDirn) - crdI(perpDirn));
theNodes[counterI] = nodeI;
theNodes[counterJ] = nodeJ;
counterI+=2;
counterJ+=2;
counter++;
}
}
}
//
// create the data description for the OutputHandler & compute length between nodes
//
int numDbColumns = timeOffset + numNodes;
std::vector<std::string> dbColumns(numDbColumns);
static std::string aColumn; // assumes a column name will not be longer than 256 characters
if(echoTimeFlag == true)
{
dbColumns[0] = "time";
}
for(int k=0; k<numNodes; k++)
{
Node *nodI= theNodes[2*k];
Node *nodJ= theNodes[2*k+1];
int ni = nodI->getTag();
int nj = nodJ->getTag();
//sprintf(aColumn, "Drift%d_%d_%d", ni, nj, perpDirn);
aColumn= "Drift_" + boost::lexical_cast<std::string>(ni) + "_"
+ boost::lexical_cast<std::string>(nj) + "_"
+ boost::lexical_cast<std::string>(perpDirn);
dbColumns[k+timeOffset] = aColumn;
}
//
// call open in the handler with the data description
//
if(theHandler)
theHandler->open(dbColumns);
//
// mark as having been done & return
//
return 0;
}
// check if limit state surface has been reached
int
ShearCurve::checkElementState(double springForce)
{
DummyStream dummy;
// find associated beam-column elementon first visit
if (theElement == 0)
{
theElement = theDomain->getElement(eleTag);
if (theElement == 0) {
// g3ErrorHandler->fatal("WARNING ShearCurve - no element with tag %i exists in Domain",eleTag);
}
// find length between nodes if drift is desired
if (defType == 2)
{
Node *nodeI = theDomain->getNode(ndI);
Node *nodeJ = theDomain->getNode(ndJ);
const Vector &crdI = nodeI->getCrds();
const Vector &crdJ = nodeJ->getCrds();
if (crdI(perpDirn) == crdJ(perpDirn)) {
// g3ErrorHandler->warning("%s -- Nodal projection has zero component along chosen direction",
// "AxialCurve::AxialCurve");
oneOverL = 0.0;
}
else
oneOverL = 1.0/fabs(crdJ(perpDirn) - crdI(perpDirn));
}
}
double deform; // value of deformation parameter from element
double force; // value of force parameter from element
int result; //junk variable
// Based on "defType" and "forType" calculate
// the desired response parameters "deform" and "force"
if (defType == 1) // maximum chord rotations
{
Response *theRotations =0; // integer element returns in setResponse
const char *r[1] = {"basicDeformations"}; // must be implemented in element
Vector *rotVec; //vector of chord rotations at beam-column ends
// set type of beam-column element response desired
theRotations = theElement->setResponse(r, 1, dummy);
// put element response in the vector of "myInfo"
result = theRotations->getResponse();
// access the myInfo vector containing the response (new for Version 1.2)
Information &theInfo = theRotations->getInformation();
rotVec = (theInfo.theVector);
deform = (fabs((*rotVec)(1)) > fabs((*rotVec)(2))) ?
fabs((*rotVec)(1)) : fabs((*rotVec)(2)); //use larger of two end rotations
}
else if (defType == 2) // interstory drift
{
// find associated nodes
Node *nodeI = theDomain->getNode(ndI);
Node *nodeJ = theDomain->getNode(ndJ);
// get displacements
const Vector &dispI = nodeI->getTrialDisp();
const Vector &dispJ = nodeJ->getTrialDisp();
//opserr << "Drift ndI: " << dispI(dof) << endln;
//opserr << "Drift ndJ: " << dispJ(dof) << endln;
// calc drift
double dx = fabs(dispJ(dof)-dispI(dof));
deform = dx*oneOverL;
}
else {
// g3ErrorHandler->fatal("WARNING ShearCurve - deformation type flag %i not implemented",defType);
}
Response *theForces =0;
const char *f[1] = {"localForce"}; // does not include influence of P-delta
// for P-delta use forType = 0
Vector *forceVec; //vector of basic forces from beam column
// set type of beam-column element response desired
theForces = theElement->setResponse(f, 1, dummy);
// put element response in the vector of "myInfo"
result += theForces->getResponse();
// access the myInfo vector containing the response (new for Version 1.2)
Information &theInfo = theForces->getInformation();
forceVec = (theInfo.theVector);
// Local forces (assuming no element loads)
if (forType == 0)
force = fabs(springForce); // force in associated LimitState material
else if (forType == 1)
force = fabs((*forceVec)(1)); // shear
else if (forType == 2)
force = fabs((*forceVec)(0)); // axial
else {
// g3ErrorHandler->fatal("WARNING ShearCurve - force type flag %i not implemented",forType);
}
P = fabs((*forceVec)(0));
// Determine if (deform,force) is outside limit state surface.
//
// Use absolute value of deform and force
double forceSurface = findLimit(deform); // force on surface at deform
// double deformSurface = findLimit(force); // deform on surface at force SDK
//opserr << "The shear force in the element is: " << force << endln;
//opserr << "State flag............................:" << stateFlag << endln;
//opserr << "Shear force in the column.........: " << force << endln;
//opserr << "forceSurface: " << forceSurface << endln;
if (stateFlag == 0) //prior to failure
{
if (force >= forceSurface) // on/outside failure surface
// if (deform >= deformSurface) // on/outside failure surface SDK
{
stateFlag = 1;
setDegSlope(force, deform);
// g3ErrorHandler->warning("ShearCurve - failure detected at deform = %f (Kdeg = %f) ", deform, Kdeg);
//opserr << "*********************" << endln;
opserr << "ShearCurve - failure detected....."<< endln;//SDK
// opserr << "deformSurface: " << deformSurface << endln; //SDK
//opserr << "Capacity: " << forceSurface << endln;
//opserr << "*********************" << endln;
}
else // inside failure surface
{
stateFlag = 0;
}
}
else //after failure
{
if (force >= forceSurface) // on/outside failure surface
// if (deform >= deformSurface) // on/outside failure surface SDK
{
stateFlag = 2;
}
else // inside failure surface
{
stateFlag = 3;
}
}
return stateFlag;
}
