int
LoadControl::newStep(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "LoadControl::newStep() - no associated AnalysisModel\n";
return -1;
}
// determine delta lambda for this step based on dLambda and #iter of last step
double factor = specNumIncrStep/numIncrLastStep;
deltaLambda *=factor;
if (deltaLambda < dLambdaMin)
deltaLambda = dLambdaMin;
else if (deltaLambda > dLambdaMax)
deltaLambda = dLambdaMax;
double currentLambda = theModel->getCurrentDomainTime();
currentLambda += deltaLambda;
theModel->applyLoadDomain(currentLambda);
numIncrLastStep = 0;
return 0;
}
int PFEMIntegrator::newStep(double deltaT)
{
if (deltaT <= 0.0) {
opserr << "PFEMIntegrator::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel and Domain
AnalysisModel *theModel = this->getAnalysisModel();
if(theModel == 0) {
opserr << "Analysis model has not been linked - PFEMIntegrator::newStep()\n";
return -1;
}
Domain* theDomain = theModel->getDomainPtr();
if(theDomain == 0) {
opserr<<"WARNING: no domain is set for the model";
opserr<<" -- PFEMIntegrator::newStep()\n";
return -1;
}
// set the constants
c1 = deltaT;
c2 = 1.0;
c3 = 1.0/deltaT;
c4 = deltaT*deltaT;
c5 = deltaT;
c6 = 1.0;
// check if domainchange() is called
if (U == 0) {
opserr << "PFEMIntegrator::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+deltaT of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// determinte new disps and accels
U->addVector(1.0, *Utdot, deltaT);
Udotdot->Zero();
// set states
theModel->setDisp(*U);
theModel->setAccel(*Udotdot);
// increment the time to t+deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "PFEMIntegrator::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
int CollocationHSIncrReduct::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CollocationHSIncrReduct::commit() - no AnalysisModel set\n";
return -1;
}
// determine response quantities at t+deltaT
Udotdot->addVector(1.0/theta, *Utdotdot, (theta-1.0)/theta);
(*Udot) = *Utdot;
double a1 = deltaT*(1.0 - gamma);
double a2 = deltaT*gamma;
Udot->addVector(1.0, *Utdotdot, a1);
Udot->addVector(1.0, *Udotdot, a2);
(*U) = *Ut;
U->addVector(1.0, *Utdot, deltaT);
double a3 = deltaT*deltaT*(0.5 - beta);
double a4 = deltaT*deltaT*beta;
U->addVector(1.0, *Utdotdot, a3);
U->addVector(1.0, *Udotdot, a4);
// update the response at the DOFs
theModel->setResponse(*U, *Udot, *Udotdot);
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += (1.0-theta)*deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
}
int HHT::newStep(double _deltaT)
{
deltaT = _deltaT;
if (beta == 0 || gamma == 0 ) {
opserr << "HHT::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta = " << beta << endln;
return -1;
}
if (deltaT <= 0.0) {
opserr << "HHT::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set the constants
c1 = 1.0;
c2 = gamma/(beta*deltaT);
c3 = 1.0/(beta*deltaT*deltaT);
if (U == 0) {
opserr << "HHT::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+deltaT of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// determine new velocities and accelerations at t+deltaT
double a1 = (1.0 - gamma/beta);
double a2 = deltaT*(1.0 - 0.5*gamma/beta);
Udot->addVector(a1, *Utdotdot, a2);
double a3 = -1.0/(beta*deltaT);
double a4 = 1.0 - 0.5/beta;
Udotdot->addVector(a4, *Utdot, a3);
// determine the velocities at t+alpha*deltaT
(*Ualphadot) = *Utdot;
Ualphadot->addVector((1.0-alpha), *Udot, alpha);
// set the trial response quantities
theModel->setVel(*Ualphadot);
theModel->setAccel(*Udotdot);
// increment the time to t+alpha*deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += alpha*deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "HHT::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
void TRBDF2::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t TRBDF2 - currentTime: " << currentTime;
} else
s << "\t TRBDF2 - no associated AnalysisModel\n";
}
int NewmarkHSFixedNumIter::newStep(double deltaT)
{
if (beta == 0 || gamma == 0) {
opserr << "NewmarkHSFixedNumIter::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta = " << beta << endln;
return -1;
}
if (deltaT <= 0.0) {
opserr << "NewmarkHSFixedNumIter::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set the constants
c1 = 1.0;
c2 = gamma/(beta*deltaT);
c3 = 1.0/(beta*deltaT*deltaT);
if (U == 0) {
opserr << "NewmarkHSFixedNumIter::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+deltaT of previous step
(*Utm2) = *Utm1;
(*Utm1) = *Ut;
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// determine new velocities and accelerations at t+deltaT
double a1 = (1.0 - gamma/beta);
double a2 = deltaT*(1.0 - 0.5*gamma/beta);
Udot->addVector(a1, *Utdotdot, a2);
double a3 = -1.0/(beta*deltaT);
double a4 = 1.0 - 0.5/beta;
Udotdot->addVector(a4, *Utdot, a3);
// set the trial response quantities
theModel->setVel(*Udot);
theModel->setAccel(*Udotdot);
// increment the time to t+deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += deltaT;
theModel->applyLoadDomain(time);
//correctForce = true;
return 0;
}
int NewmarkExplicit::newStep(double deltaT)
{
updateCount = 0;
if (gamma == 0) {
opserr << "NewmarkExplicit::newStep() - error in variable\n";
opserr << "gamma = " << gamma << endln;
return -1;
}
if (deltaT <= 0.0) {
opserr << "NewmarkExplicit::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set the constants
c2 = gamma*deltaT;
c3 = 1.0;
if (U == 0) {
opserr << "NewmarkExplicit::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+deltaT of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// determine new response at time t+deltaT
U->addVector(1.0, *Utdot, deltaT);
double a1 = 0.5*deltaT*deltaT;
U->addVector(1.0, *Utdotdot, a1);
double a2 = deltaT*(1.0 - gamma);
Udot->addVector(1.0, *Utdotdot, a2);
Udotdot->Zero();
// set the trial response quantities
theModel->setResponse(*U, *Udot, *Udotdot);
// increment the time to t+deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "NewmarkExplicit::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
void PFEMIntegrator::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t PFEMIntegrator - currentTime: " << currentTime;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "\t PFEMIntegrator - no associated AnalysisModel\n";
}
void
CentralDifferenceNoDamping::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t CentralDifferenceNoDamping - currentTime: " << currentTime;
} else
s << "\t CentralDifferenceNoDamping - no associated AnalysisModel\n";
}
void CentralDifference::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t CentralDifference - currentTime: " << currentTime << endln;
s << " Rayleigh Damping - alphaM: " << alphaM << " betaK: " << betaK;
s << " betaKi: " << betaKi << " betaKc: " << betaKc << endln;
} else
s << "\t CentralDifference - no associated AnalysisModel\n";
}
void HHTGeneralized_TP::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t HHTGeneralized_TP - currentTime: " << currentTime << endln;
s << " alphaI: " << alphaI << " alphaF: " << alphaF << " beta: " << beta << " gamma: " << gamma << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "\t HHTGeneralized_TP - no associated AnalysisModel\n";
}
int CollocationHSFixedNumIter::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CollocationHSFixedNumIter::commit() - no AnalysisModel set\n";
return -1;
}
LinearSOE *theSOE = this->getLinearSOE();
if (theSOE == 0) {
opserr << "WARNING CollocationHSFixedNumIter::commit() - no LinearSOE set\n";
return -2;
}
if (theSOE->solve() < 0) {
opserr << "WARNING CollocationHSFixedNumIter::commit() - "
<< "the LinearSysOfEqn failed in solve()\n";
return -3;
}
const Vector &deltaU = theSOE->getX();
// determine the response at t+theta*deltaT
U->addVector(1.0, deltaU, c1);
Udot->addVector(1.0, deltaU, c2);
Udotdot->addVector(1.0, deltaU, c3);
// determine response quantities at t+deltaT
Udotdot->addVector(1.0/theta, *Utdotdot, (theta-1.0)/theta);
(*Udot) = *Utdot;
double a1 = deltaT*(1.0 - gamma);
double a2 = deltaT*gamma;
Udot->addVector(1.0, *Utdotdot, a1);
Udot->addVector(1.0, *Udotdot, a2);
(*U) = *Ut;
U->addVector(1.0, *Utdot, deltaT);
double a3 = deltaT*deltaT*(0.5 - beta);
double a4 = deltaT*deltaT*beta;
U->addVector(1.0, *Utdotdot, a3);
U->addVector(1.0, *Udotdot, a4);
// update the response at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += (1.0-theta)*deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
}
void NewmarkExplicit::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "NewmarkExplicit - currentTime: " << currentTime << endln;
s << " gamma: " << gamma << endln;
s << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "NewmarkExplicit - no associated AnalysisModel\n";
}
void KRAlphaExplicit::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "KRAlphaExplicit - currentTime: " << currentTime << endln ;
s << " alphaM: " << alphaM << " alphaF: " << alphaF << " beta: " << beta << " gamma: " << gamma << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "KRAlphaExplicit - no associated AnalysisModel\n";
}
int CollocationHSIncrReduct::newStep(double _deltaT)
{
if (theta <= 0.0 ) {
opserr << "CollocationHSIncrReduct::newStep() - error in variable\n";
opserr << "theta: " << theta << " <= 0.0\n";
return -1;
}
deltaT = _deltaT;
if (deltaT <= 0.0) {
opserr << "CollocationHSIncrReduct::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set the constants
c1 = 1.0;
c2 = gamma/(beta*theta*deltaT);
c3 = 1.0/(beta*theta*theta*deltaT*deltaT);
if (U == 0) {
opserr << "CollocationHSIncrReduct::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+deltaT of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// determine new velocities and accelerations at t+theta*deltaT
double a1 = (1.0 - gamma/beta);
double a2 = theta*deltaT*(1.0 - 0.5*gamma/beta);
Udot->addVector(a1, *Utdotdot, a2);
double a3 = -1.0/(beta*theta*deltaT);
double a4 = 1.0 - 0.5/beta;
Udotdot->addVector(a4, *Utdot, a3);
// set the trial response quantities
theModel->setVel(*Udot);
theModel->setAccel(*Udotdot);
// increment the time to t+theta*deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += theta*deltaT;
theModel->applyLoadDomain(time);
return 0;
}
void
LoadControl::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentLambda = theModel->getCurrentDomainTime();
s << "\t LoadControl - currentLambda: " << currentLambda;
s << " deltaLambda: " << deltaLambda << endln;
} else
s << "\t LoadControl - no associated AnalysisModel\n";
}
void NewmarkHSFixedNumIter::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "NewmarkHSFixedNumIter - currentTime: " << currentTime;
s << " gamma: " << gamma << " beta: " << beta << endln;
s << " polyOrder: " << polyOrder << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "NewmarkHSFixedNumIter - no associated AnalysisModel\n";
}
void CollocationHSIncrReduct::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "CollocationHSIncrReduct - currentTime: " << currentTime << endln;
s << " theta: " << theta << endln;
s << " reduct: " << reduct << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
} else
s << "CollocationHSIncrReduct - no associated AnalysisModel\n";
}
void
ArcLength::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double cLambda = theModel->getCurrentDomainTime();
s << "\t ArcLength - currentLambda: " << cLambda;
s << " arcLength: " << sqrt(arcLength2) << " alpha: ";
s << sqrt(alpha2) << endln;
} else
s << "\t ArcLength - no associated AnalysisModel\n";
}
void
ArcLengthw::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double cLambda = theModel->getCurrentDomainTime();
s << "\t ArcLengthw - currentLambda: " << cLambda;
s << " Initial Load Factor: " << iFactor << " Jd: ";
s << Jd << endln;
} else
s << "\t ArcLengthw - no associated AnalysisModel\n";
}
void
HHT1::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "\t HHT1 - currentTime: " << currentTime << " alpha: ";
s << alpha << " gamma: " << gamma << " beta: " << beta << endln;
s << " Rayleigh Damping - alphaM: " << alphaM;
s << " betaK: " << betaK << " betaKi: " << betaKi << endln;
} else
s << "\t HHT1 - no associated AnalysisModel\n";
}
void CollocationHSIncrLimit::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "CollocationHSIncrLimit - currentTime: " << currentTime << endln;
s << " theta: " << theta << endln;
s << " limit: " << limit << " normType: " << normType << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
s << " Rayleigh Damping - alphaM: " << alphaM << " betaK: " << betaK;
s << " betaKi: " << betaKi << " betaKc: " << betaKc << endln;
} else
s << "CollocationHSIncrLimit - no associated AnalysisModel\n";
}
void HHTHSFixedNumIter::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "HHTHSFixedNumIter - currentTime: " << currentTime << endln;
s << " alphaI: " << alphaI << " alphaF: " << alphaF << " beta: " << beta << " gamma: " << gamma << endln;
s << " polyOrder: " << polyOrder << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
s << " Rayleigh Damping - alphaM: " << alphaM << " betaK: " << betaK;
s << " betaKi: " << betaKi << " betaKc: " << betaKc << endln;
} else
s << "HHTHSFixedNumIter - no associated AnalysisModel\n";
}
int
ArcLength::newStep(void)
{
// get pointers to AnalysisModel and LinearSOE
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING ArcLength::newStep() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
// get the current load factor
currentLambda = theModel->getCurrentDomainTime();
if (deltaLambdaStep < 0)
signLastDeltaLambdaStep = -1;
else
signLastDeltaLambdaStep = +1;
// determine dUhat
this->formTangent();
theLinSOE->setB(*phat);
if (theLinSOE->solve() < 0) {
opserr << "ArcLength::newStep(void) - failed in solver\n";
return -1;
}
(*deltaUhat) = theLinSOE->getX();
Vector &dUhat = *deltaUhat;
// determine delta lambda(1) == dlambda
double dLambda = sqrt(arcLength2/((dUhat^dUhat)+alpha2));
dLambda *= signLastDeltaLambdaStep; // base sign of load change
// on what was happening last step
deltaLambdaStep = dLambda;
currentLambda += dLambda;
// determine delta U(1) == dU
(*deltaU) = dUhat;
(*deltaU) *= dLambda;
(*deltaUstep) = (*deltaU);
// update model with delta lambda and delta U
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
theModel->updateDomain();
return 0;
}
int AlphaOSGeneralized::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING AlphaOSGeneralized::commit() - no AnalysisModel set\n";
return -1;
}
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += (1.0-alphaF)*deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
}
void AlphaOSGeneralized::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "AlphaOSGeneralized - currentTime: " << currentTime << endln;
s << " alphaI: " << alphaI << " alphaF: " << alphaF << " beta: " << beta << " gamma: " << gamma << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
if (updDomFlag)
s << " update Domain: yes\n";
else
s << " update Domain: no\n";
} else
s << "AlphaOSGeneralized - no associated AnalysisModel\n";
}
int CentralDifference::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CentralDifference::commit() - no AnalysisModel set\n";
return -1;
}
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
}
void AlphaOS::Print(OPS_Stream &s, int flag)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel != 0) {
double currentTime = theModel->getCurrentDomainTime();
s << "AlphaOS - currentTime: " << currentTime << endln;
s << " alpha: " << alpha << " beta: " << beta << " gamma: " << gamma << endln;
s << " c1: " << c1 << " c2: " << c2 << " c3: " << c3 << endln;
if (updElemDisp)
s << " updateElemDisp: yes\n";
else
s << " updateElemDisp: no\n";
} else
s << "AlphaOS - no associated AnalysisModel\n";
}
int
CentralDifferenceNoDamping::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CentralDifferenceNoDamping::commit() - no AnalysisModel set\n";
return -1;
}
// update time in Domain to T + deltaT & commit the domain
double time = theModel->getCurrentDomainTime() + deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
return 0;
}
int CentralDifference::newStep(double _deltaT)
{
updateCount = 0;
deltaT = _deltaT;
if (deltaT <= 0.0) {
opserr << "CentralDifference::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set the constants
c2 = 0.5/deltaT;
c3 = 1.0/(deltaT*deltaT);
if (Ut == 0) {
opserr << "CentralDifference::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// determine the garbage velocities and accelerations at t
Utdot->addVector(0.0, *Utm1, -c2);
Utdotdot->addVector(0.0, *Ut, -2.0*c3);
Utdotdot->addVector(1.0, *Utm1, c3);
// set the garbage response quantities for the nodes
theModel->setVel(*Utdot);
theModel->setAccel(*Utdotdot);
// increment the time to t and apply the load
double time = theModel->getCurrentDomainTime();
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "CentralDifference::newStep() - failed to update the domain\n";
return -4;
}
// set response at t to be that at t+deltaT of previous step
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
return 0;
}