int
EnvelopeNodeRecorder::record(int commitTag, double timeStamp)
{
if (theDomain == 0 || theDofs == 0) {
return 0;
}
if (theHandler == 0) {
opserr << "EnvelopeNodeRecorder::record() - no DataOutputHandler has been set\n";
return -1;
}
if (initializationDone != true)
if (this->initialize() != 0) {
opserr << "EnvelopeNodeRecorder::record() - failed in initialize()\n";
return -1;
}
int numDOF = theDofs->Size();
if (deltaT == 0.0 || timeStamp >= nextTimeStampToRecord) {
if (deltaT != 0.0)
nextTimeStampToRecord = timeStamp + deltaT;
double timeSeriesTerm = 0.0;
if (theTimeSeries != 0) {
timeSeriesTerm += theTimeSeries->getFactor(timeStamp);
}
//
// if need nodal reactions get the domain to calculate them
// before we iterate over the nodes
//
if (dataFlag == 7)
theDomain->calculateNodalReactions(0);
else if (dataFlag == 8)
theDomain->calculateNodalReactions(1);
if (dataFlag == 9)
theDomain->calculateNodalReactions(2);
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF;
Node *theNode = theNodes[i];
if (dataFlag == 0) {
const Vector &response = theNode->getTrialDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
}else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 1) {
const Vector &response = theNode->getTrialVel();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
} else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 2) {
const Vector &response = theNode->getTrialAccel();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
} else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 3) {
const Vector &response = theNode->getIncrDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 4) {
const Vector &response = theNode->getIncrDeltaDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 5) {
const Vector &theResponse = theNode->getUnbalancedLoad();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 6) {
const Vector &theResponse = theNode->getUnbalancedLoadIncInertia();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 7 || dataFlag == 8 || dataFlag == 9) {
const Vector &theResponse = theNode->getReaction();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag > 10) {
int mode = dataFlag - 10;
int column = mode - 1;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
(*currentData)(cnt) = theEigenvectors(dof,column);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else {
for (int j=0; j<numDOF; j++) {
(*currentData)(cnt) = 0.0;
cnt++;
}
}
}
}
}
// check if currentData modifies the saved data
int sizeData = currentData->Size();
if (echoTimeFlag == false) {
bool writeIt = false;
if (first == true) {
for (int i=0; i<sizeData; i++) {
(*data)(0,i) = (*currentData)(i);
(*data)(1,i) = (*currentData)(i);
(*data)(2,i) = fabs((*currentData)(i));
first = false;
writeIt = true;
}
} else {
for (int i=0; i<sizeData; i++) {
double value = (*currentData)(i);
if ((*data)(0,i) > value) {
(*data)(0,i) = value;
double absValue = fabs(value);
if ((*data)(2,i) < absValue)
(*data)(2,i) = absValue;
writeIt = true;
} else if ((*data)(1,i) < value) {
(*data)(1,i) = value;
double absValue = fabs(value);
if ((*data)(2,i) < absValue)
(*data)(2,i) = absValue;
writeIt = true;
}
}
}
} else {
sizeData /= 2;
bool writeIt = false;
if (first == true) {
for (int i=0; i<sizeData; i++) {
(*data)(0,i*2) = timeStamp;
(*data)(1,i*2) = timeStamp;
(*data)(2,i*2) = timeStamp;
(*data)(0,i*2+1) = (*currentData)(i);
(*data)(1,i*2+1) = (*currentData)(i);
(*data)(2,i*2+1) = fabs((*currentData)(i));
first = false;
writeIt = true;
}
} else {
for (int i=0; i<sizeData; i++) {
double value = (*currentData)(i);
if ((*data)(0,2*i+1) > value) {
(*data)(0,i*2) = timeStamp;
(*data)(0,i*2+1) = value;
double absValue = fabs(value);
if ((*data)(2,i*2+1) < absValue) {
(*data)(2,i*2+1) = absValue;
(*data)(2,i*2) = timeStamp;
}
writeIt = true;
} else if ((*data)(1,i*2+1) < value) {
(*data)(1,i*2) = timeStamp;
(*data)(1,i*2+1) = value;
double absValue = fabs(value);
if ((*data)(2,i*2+1) < absValue) {
(*data)(2,i*2) = timeStamp;
(*data)(2,i*2+1) = absValue;
}
writeIt = true;
}
}
}
}
return 0;
}
int
NodeRecorder::record(int commitTag, double timeStamp)
{
if (theDomain == 0 || theDofs == 0) {
return 0;
}
if (theOutputHandler == 0) {
opserr << "NodeRecorder::record() - no DataOutputHandler has been set\n";
return -1;
}
if (initializationDone == false) {
if (this->initialize() != 0) {
opserr << "NodeRecorder::record() - failed in initialize()\n";
return -1;
}
}
int numDOF = theDofs->Size();
if (deltaT == 0.0 || timeStamp >= nextTimeStampToRecord) {
if (deltaT != 0.0)
nextTimeStampToRecord = timeStamp + deltaT;
//
// if need nodal reactions get the domain to calculate them
// before we iterate over the nodes
//
if (dataFlag == 7)
theDomain->calculateNodalReactions(0);
else if (dataFlag == 8)
theDomain->calculateNodalReactions(1);
if (dataFlag == 9)
theDomain->calculateNodalReactions(2);
//
// add time information if requested
//
int timeOffset = 0;
if (echoTimeFlag == true) {
timeOffset = 1;
response(0) = timeStamp;
}
double timeSeriesTerm = 0.0;
if (theTimeSeries != 0) {
for (int i=0; i<numDOF; i++) {
if (theTimeSeries[i] != 0)
timeSeriesValues[i] = theTimeSeries[i]->getFactor(timeStamp);
}
}
//
// now we go get the responses from the nodes & place them in disp vector
//
if (dataFlag != 10) {
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF + timeOffset;
if (dataFlag == 10000)
cnt = i + timeOffset;
Node *theNode = theNodes[i];
if (dataFlag == 0) {
// AddingSensitivity:BEGIN ///////////////////////////////////
if (sensitivity==0) {
const Vector &theResponse = theNode->getTrialDisp();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
}
else {
response(cnt) = 0.0 + timeSeriesTerm;
}
cnt++;
}
}
else {
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
response(cnt) = theNode->getDispSensitivity(dof+1, sensitivity);
cnt++;
}
}
// AddingSensitivity:END /////////////////////////////////////
} else if (dataFlag == 1) {
const Vector &theResponse = theNode->getTrialVel();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
} else
response(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 10000) {
const Vector &theResponse = theNode->getTrialDisp();
double sum = 0.0;
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
sum += (theResponse(dof) + timeSeriesTerm) * (theResponse(dof) + timeSeriesTerm);
} else
sum += timeSeriesTerm * timeSeriesTerm;
}
response(cnt) = sqrt(sum);
cnt++;
} else if (dataFlag == 2) {
const Vector &theResponse = theNode->getTrialAccel();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
} else
response(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 3) {
const Vector &theResponse = theNode->getIncrDisp();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 4) {
const Vector &theResponse = theNode->getIncrDeltaDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 5) {
const Vector &theResponse = theNode->getUnbalancedLoad();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 6) {
const Vector &theResponse = theNode->getUnbalancedLoadIncInertia();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 7 || dataFlag == 8 || dataFlag == 9) {
const Vector &theResponse = theNode->getReaction();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (10 <= dataFlag && dataFlag < 1000) {
int mode = dataFlag - 10;
int column = mode - 1;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
response(cnt) = theEigenvectors(dof,column);
} else
response(cnt) = 0.0;
cnt++;
}
}
} else if (dataFlag >= 1000 && dataFlag < 2000) {
int grad = dataFlag - 1000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getDispSensitivity(dof, grad-1); // Quan May 2009, the one above is not my comment!
cnt++;
}
} else if (dataFlag >= 2000 && dataFlag < 3000) {
int grad = dataFlag - 2000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getVelSensitivity(dof, grad-1); // Quan May 2009
cnt++;
}
} else if (dataFlag >= 3000) {
int grad = dataFlag - 3000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getAccSensitivity(dof, grad-1);// Quan May 2009
cnt++;
}
}
else {
// unknown response
for (int j=0; j<numDOF; j++) {
response(cnt) = 0.0;
}
}
}
// insert the data into the database
theOutputHandler->write(response);
} else { // output all eigenvalues
Node *theNode = theNodes[0];
const Matrix &theEigenvectors = theNode->getEigenvectors();
int numValidModes = theEigenvectors.noCols();
for (int mode=0; mode<numValidModes; mode++) {
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF + timeOffset;
theNode = theNodes[i];
int column = mode;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
response(cnt) = theEigenvectors(dof,column);
} else
response(cnt) = 0.0;
cnt++;
}
}
}
theOutputHandler->write(response);
}
}
}
return 0;
}
