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 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;
}
int
DisplacementControl::update(const Vector &dU)
{
if (theDofID == -1) {
opserr << "DisplacementControl::newStep() - domainChanged has not been called\n";
return -1;
}
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;
}
(*deltaUbar) = dU; // have to do this as the SOE is gonna change
double dUabar = (*deltaUbar)(theDofID);
// determine dUhat
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
double dUahat = (*deltaUhat)(theDofID);
if (dUahat == 0.0) {
opserr << "WARNING DisplacementControl::update() ";
opserr << "dUahat is zero -- zero reference displacement at control node DOF\n";
return -1;
}
// determine delta lambda(1) == dlambda
double dLambda = -dUabar/dUahat;
// determine delta U(i)
(*deltaU) = (*deltaUbar);
deltaU->addVector(1.0, *deltaUhat,dLambda);
// update dU and dlambda
(*deltaUstep) += *deltaU;
deltaLambdaStep += dLambda;
currentLambda += dLambda;
// update the model
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
if (theModel->updateDomain() < 0) {
opserr << "DisplacementControl::update - model failed to update for new dU\n";
return -1;
}
// set the X soln in linearSOE to be deltaU for convergence Test
theLinSOE->setX(*deltaU);
numIncrLastStep++;
return 0;
}
int NewmarkHSFixedNumIter::update(const Vector &deltaU)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING NewmarkHSFixedNumIter::update() - no AnalysisModel set\n";
return -1;
}
ConvergenceTest *theTest = this->getConvergenceTest();
if (theTest == 0) {
opserr << "WARNING NewmarkHSFixedNumIter::update() - no ConvergenceTest set\n";
return -2;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING NewmarkHSFixedNumIter::update() - domainChange() failed or not called\n";
return -3;
}
// check deltaU is of correct size
if (deltaU.Size() != U->Size()) {
opserr << "WARNING NewmarkHSFixedNumIter::update() - Vectors of incompatible size";
opserr << " expecting " << U->Size() << " obtained " << deltaU.Size() << endln;
return -4;
}
// get interpolation location and scale displacement increment
x = (double) theTest->getNumTests()/theTest->getMaxNumTests();
if (polyOrder == 1) {
(*scaledDeltaU) = x*((*U)+deltaU) - (x-1.0)*(*Ut) - (*U);
}
else if (polyOrder == 2) {
(*scaledDeltaU) = x*(x+1.0)/2.0*((*U)+deltaU) - (x-1.0)*(x+1.0)*(*Ut)
+ (x-1.0)*x/2.0*(*Utm1) - (*U);
}
else if (polyOrder == 3) {
(*scaledDeltaU) = x*(x+1.0)*(x+2.0)/6.0*((*U)+deltaU) - (x-1.0)*(x+1.0)*(x+2.0)/2.0*(*Ut)
+ (x-1.0)*x*(x+2.0)/2.0*(*Utm1) - (x-1.0)*x*(x+1.0)/6.0*(*Utm2) - (*U);
}
else {
opserr << "WARNING NewmarkHSFixedNumIter::update() - polyOrder > 3 not supported\n";
}
// determine the response at t+deltaT
U->addVector(1.0, *scaledDeltaU, c1);
Udot->addVector(1.0, *scaledDeltaU, c2);
Udotdot->addVector(1.0, *scaledDeltaU, c3);
// update the response at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "NewmarkHSFixedNumIter::update() - failed to update the domain\n";
return -5;
}
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;
}
int CentralDifference::update(const Vector &U)
{
updateCount++;
if (updateCount > 1) {
opserr << "WARNING CentralDifference::update() - called more than once -";
opserr << " CentralDifference integration scheme requires a LINEAR solution algorithm\n";
return -1;
}
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CentralDifference::update() - no AnalysisModel set\n";
return -1;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING CentralDifference::update() - domainChange() failed or not called\n";
return -2;
}
// check U is of correct size
if (U.Size() != Ut->Size()) {
opserr << "WARNING CentralDifference::update() - Vectors of incompatible size ";
opserr << " expecting " << Ut->Size() << " obtained " << U.Size() << endln;
return -3;
}
// determine the response at t+deltaT
Udot->addVector(0.0, U, 3.0);
Udot->addVector(1.0, *Ut, -4.0);
Udot->addVector(1.0, *Utm1, 1.0);
(*Udot) *= c2;
Udotdot->addVector(0.0, *Udot, 1.0);
Udotdot->addVector(1.0, *Utdot, -1.0);
(*Udotdot) /= deltaT;
// update the response at the DOFs
theModel->setResponse(U, *Udot, *Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "CentralDifference::update() - failed to update the domain\n";
return -4;
}
// set response at t to be that at t+deltaT of previous step
(*Utm1) = *Ut;
(*Ut) = U;
return 0;
}
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 AlphaOS::update(const Vector &deltaU)
{
updateCount++;
if (updateCount > 1) {
opserr << "WARNING AlphaOS::update() - called more than once -";
opserr << " AlphaOS integration scheme requires a LINEAR solution algorithm\n";
return -1;
}
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING AlphaOS::update() - no AnalysisModel set\n";
return -2;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING AlphaOS::update() - domainChange() failed or not called\n";
return -3;
}
// check deltaU is of correct size
if (deltaU.Size() != U->Size()) {
opserr << "WARNING AlphaOS::update() - Vectors of incompatible size ";
opserr << " expecting " << U->Size() << " obtained " << deltaU.Size() << "\n";
return -4;
}
// save the predictor displacements
(*Upt) = *U;
// determine the response at t+deltaT
U->addVector(1.0, deltaU, c1);
Udot->addVector(1.0, deltaU, c2);
Udotdot->addVector(0.0, deltaU, c3);
// update the response at the DOFs
theModel->setVel(*Udot);
theModel->setAccel(*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "AlphaOS::update() - failed to update the domain\n";
return -5;
}
// do not update displacements in elements only at nodes
theModel->setDisp(*U);
return 0;
}
int
HHT1::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING HHT1::commit() - no AnalysisModel set\n";
return -1;
}
// update the responses at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
theModel->updateDomain();
return theModel->commitDomain();
}
int
CentralDifferenceAlternative::update(const Vector &X)
{
updateCount++;
if (updateCount > 1) {
opserr << "ERROR CentralDifferenceAlternative::update() - called more than once -";
opserr << " Central Difference integraion schemes require a LINEAR solution algorithm\n";
return -1;
}
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "ERROR CentralDifferenceAlternative::update() - no AnalysisModel set\n";
return -2;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING CentralDifferenceAlternative::update() - domainChange() failed or not called\n";
return -2;
}
// check deltaU is of correct size
if (X.Size() != Ut->Size()) {
opserr << "WARNING CentralDifferenceAlternative::update() - Vectors of incompatible size ";
opserr << " expecting " << Ut->Size() << " obtained " << X.Size() << endln;
return -3;
}
// determine the displacement at t+delta t
Utp1->addVector(0.0, X, deltaT * deltaT);
(*Utp1) += *Ut;
Utp1->addVector(1.0, *Udot, deltaT);
// determine the vel at t+ 0.5 * delta t
(*Udot) = *Utp1;
(*Udot) -= *Ut;
(*Udot) *= (1.0/deltaT);
// update the disp & responses at the DOFs
theModel->setDisp(*Utp1);
theModel->setVel(*Udot);
theModel->updateDomain();
return 0;
}
int GeneralizedAlpha::update(const Vector &deltaU)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING GeneralizedAlpha::update() - no AnalysisModel set\n";
return -1;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING GeneralizedAlpha::update() - domainChange() failed or not called\n";
return -2;
}
// check deltaU is of correct size
if (deltaU.Size() != U->Size()) {
opserr << "WARNING GeneralizedAlpha::update() - Vectors of incompatible size ";
opserr << " expecting " << U->Size() << " obtained " << deltaU.Size() << endln;
return -3;
}
// determine the response at t+deltaT
(*U) += deltaU;
Udot->addVector(1.0, deltaU, c2);
Udotdot->addVector(1.0, deltaU, c3);
// determine displacement and velocity at t+alphaF*deltaT
(*Ualpha) = *Ut;
Ualpha->addVector((1.0-alphaF), *U, alphaF);
(*Ualphadot) = *Utdot;
Ualphadot->addVector((1.0-alphaF), *Udot, alphaF);
// determine the velocities at t+alphaM*deltaT
(*Ualphadotdot) = *Utdotdot;
Ualphadotdot->addVector((1.0-alphaM), *Udotdot, alphaM);
// update the response at the DOFs
theModel->setResponse(*Ualpha,*Ualphadot,*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "GeneralizedAlpha::update() - failed to update the domain\n";
return -4;
}
return 0;
}
int
ArcLength1::update(const Vector &dU)
{
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING ArcLength1::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
(*deltaUbar) = dU; // have to do this as the SOE is gonna change
// determine dUhat
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
// determine delta lambda(i)
double a = (*deltaUstep)^(*deltaUbar);
double b = (*deltaUstep)^(*deltaUhat) + alpha2*deltaLambdaStep;
if (b == 0) {
opserr << "ArcLength1::update() - zero denominator,";
opserr << " alpha was set to 0.0 and zero reference load\n";
return -1;
}
double dLambda = -a/b;
// determine delta U(i)
(*deltaU) = (*deltaUbar);
deltaU->addVector(1.0, *deltaUhat,dLambda);
// update dU and dlambda
(*deltaUstep) += *deltaU;
deltaLambdaStep += dLambda;
currentLambda += dLambda;
// update the model
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
theModel->updateDomain();
// set the X soln in linearSOE to be deltaU for convergence Test
theLinSOE->setX(*deltaU);
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;
}
int KRAlphaExplicit::update(const Vector &aiPlusOne)
{
updateCount++;
if (updateCount > 1) {
opserr << "WARNING KRAlphaExplicit::update() - called more than once -";
opserr << " KRAlphaExplicit integration scheme requires a LINEAR solution algorithm\n";
return -1;
}
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING KRAlphaExplicit::update() - no AnalysisModel set\n";
return -1;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING KRAlphaExplicit::update() - domainChange() failed or not called\n";
return -2;
}
// check aiPlusOne is of correct size
if (aiPlusOne.Size() != U->Size()) {
opserr << "WARNING KRAlphaExplicit::update() - Vectors of incompatible size ";
opserr << " expecting " << U->Size() << " obtained " << aiPlusOne.Size() << endln;
return -3;
}
// determine the response at t+deltaT
//U->addVector(1.0, aiPlusOne, c1); // c1 = 0.0
//Udot->addVector(1.0, aiPlusOne, c2); // c2 = 0.0
Udotdot->addVector(0.0, aiPlusOne, 1.0);
// update the response at the DOFs
theModel->setResponse(*U, *Udot, *Udotdot);
if (updDomFlag == true) {
if (theModel->updateDomain() < 0) {
opserr << "WARNING KRAlphaExplicit::update() - failed to update the domain\n";
return -4;
}
}
return 0;
}
int
ArcLengthw::update(const Vector &dU)
{
ofstream factor;
factor.open("FS.dat",ios::app);
factor<<"insideupdate"<<endln;
//factor>>dU;
factor<<"insideupdate1"<<endln;
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING ArcLengthw::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
(*deltaUbar) = dU; // have to do this as the SOE is gonna change
// determine dUhat
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
double dLambda = -((*phat)^(*deltaUbar))/((*phat)^(*deltaUhat));
(*deltaU) = (*deltaUbar);
deltaU->addVector(1.0, *deltaUhat,dLambda);
// update dU and dlambda
(*deltaUstep) += *deltaU;
deltaLambdaStep += dLambda;
currentLambda += dLambda;
// update the model
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
theModel->updateDomain();
// set the X soln in linearSOE to be deltaU for convergence Test
theLinSOE->setX(*deltaU);
return 0;
}
int Newmark::update(const Vector &deltaU)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING Newmark::update() - no AnalysisModel set\n";
return -1;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING Newmark::update() - domainChange() failed or not called\n";
return -2;
}
// check deltaU is of correct size
if (deltaU.Size() != U->Size()) {
opserr << "WARNING Newmark::update() - Vectors of incompatible size ";
opserr << " expecting " << U->Size() << " obtained " << deltaU.Size() << endln;
return -3;
}
// determine the response at t+deltaT
if (displ == true) {
(*U) += deltaU;
Udot->addVector(1.0, deltaU, c2);
Udotdot->addVector(1.0, deltaU, c3);
} else {
U->addVector(1.0, deltaU, c1);
Udot->addVector(1.0, deltaU, c2);
(*Udotdot) += deltaU;
}
// update the response at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "Newmark::update() - failed to update the domain\n";
return -4;
}
return 0;
}
int CollocationHSIncrLimit::update(const Vector &deltaU)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING CollocationHSIncrLimit::update() - no AnalysisModel set\n";
return -1;
}
// check domainChanged() has been called, i.e. Ut will not be zero
if (Ut == 0) {
opserr << "WARNING CollocationHSIncrLimit::update() - domainChange() failed or not called\n";
return -3;
}
// check deltaU is of correct size
if (deltaU.Size() != U->Size()) {
opserr << "WARNING CollocationHSIncrLimit::update() - Vectors of incompatible size ";
opserr << " expecting " << U->Size() << " obtained " << deltaU.Size() << endln;
return -4;
}
// get scaled increment
double scale = limit/deltaU.pNorm(normType);
if (scale >= 1.0)
(*scaledDeltaU) = deltaU;
else
(*scaledDeltaU) = scale*deltaU;
// determine the response at t+theta*deltaT
U->addVector(1.0, *scaledDeltaU, c1);
Udot->addVector(1.0, *scaledDeltaU, c2);
Udotdot->addVector(1.0, *scaledDeltaU, c3);
// update the response at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "CollocationHSIncrLimit::update() - failed to update the domain\n";
return -5;
}
return 0;
}
int AlphaOS::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING AlphaOS::commit() - no AnalysisModel set\n";
return -1;
}
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += (1.0-alpha)*deltaT;
theModel->setCurrentDomainTime(time);
// update the displacements in the elements
if (updElemDisp == true)
theModel->updateDomain();
return theModel->commitDomain();
}
int GeneralizedAlpha::commit(void)
{
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING GeneralizedAlpha::commit() - no AnalysisModel set\n";
return -1;
}
// update the response at the DOFs
theModel->setResponse(*U,*Udot,*Udotdot);
if (theModel->updateDomain() < 0) {
opserr << "GeneralizedAlpha::commit() - failed to update the domain\n";
return -4;
}
// set the time to be t+deltaT
double time = theModel->getCurrentDomainTime();
time += (1.0-alphaF)*deltaT;
theModel->setCurrentDomainTime(time);
return theModel->commitDomain();
}
int
LoadControl::update(const Vector &deltaU)
{
AnalysisModel *myModel = this->getAnalysisModel();
LinearSOE *theSOE = this->getLinearSOE();
if (myModel == 0 || theSOE == 0) {
opserr << "WARNING LoadControl::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
myModel->incrDisp(deltaU);
if (myModel->updateDomain() < 0) {
opserr << "LoadControl::update - model failed to update for new dU\n";
return -1;
}
// Set deltaU for the convergence test
theSOE->setX(deltaU);
numIncrLastStep++;
return 0;
}
int
HHT1::newStep(double deltaT)
{
if (beta == 0 || gamma == 0 ) {
opserr << "HHT1::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta= " << beta << endln;
return -1;
}
if (deltaT <= 0.0) {
opserr << "HHT1::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
c1 = 1.0;
c2 = gamma/(beta*deltaT);
c3 = 1.0/(beta*deltaT*deltaT);
AnalysisModel *theModel = this->getAnalysisModel();
if (U == 0) {
opserr << "HHT1::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// set response at t to be that at t+delta t of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// set new velocity and accelerations at t + delta t
double a1 = (1.0 - gamma/beta);
double a2 = (deltaT)*(1.0 - 0.5*gamma/beta);
// (*Udot) *= a1;
Udot->addVector(a1, *Utdotdot,a2);
double a3 = -1.0/(beta*deltaT);
double a4 = 1 - 0.5/beta;
// (*Udotdot) *= a4;
Udotdot->addVector(a4, *Utdot,a3);
(*Ualpha) = *Ut;
(*Udotalpha) = *Utdot;
// (*Udotalpha) *= (1 - alpha);
Udotalpha->addVector((1-alpha), *Udot, alpha);
// set the new trial response quantities
theModel->setResponse(*Ualpha,*Udotalpha,*Udotdot);
// increment the time and apply the load
double time = theModel->getCurrentDomainTime();
time +=deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "HHT::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
int TRBDF2::newStep(double deltaT)
{
// check the vectors have been created
if (U == 0) {
opserr << "TRBDF2::newStep() - domainChange() failed or hasn't been called\n";
return -3;
}
// mark step as Trapezoidal (=0) or Backward Euler (=1)
if (deltaT != dt || step == 1) {
step = 0;
} else
step = 1;
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
// set response at t to be that at t+deltaT of previous step
dt = deltaT;
(*Utm1) = *Ut;
(*Utm1dot) = *Utdot;
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// set the constants
if (step == 0) { // trapezoidal
c1 = 1.0;
c2 = 2.0/deltaT;
c3 = 4.0/(deltaT*deltaT);
(*Udot) *= -1.0;
double a3 = -4.0/deltaT;
double a4 = -1;
Udotdot->addVector(a4, *Utdot, a3);
// set the trial response quantities
theModel->setVel(*Udot);
theModel->setAccel(*Udotdot);
} else { // backward euler
c1 = 1.0;
c2 = 1.5/deltaT;
c3 = 2.25/(deltaT*deltaT);
(*Udot) = *Utm1;
Udot->addVector(0.5/deltaT, *Ut, -1/(2.0*deltaT));
(*Udotdot) = *Utm1dot;
Udotdot->addVector(0.5/deltaT, *Utdot, -4.0/(2.0*deltaT));
Udotdot->addVector(1.0, *Udot, 3.0/(2.0*deltaT));
// 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;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "TRBDF2::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
int HHTGeneralized_TP::newStep(double _deltaT)
{
if (beta == 0 || gamma == 0 ) {
opserr << "HHTGeneralized_TP::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta = " << beta << endln;
return -1;
}
deltaT = _deltaT;
if (deltaT <= 0.0) {
opserr << "HHTGeneralized_TP::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -2;
}
// get a pointer to the LinearSOE and the AnalysisModel
LinearSOE *theLinSOE = this->getLinearSOE();
AnalysisModel *theModel = this->getAnalysisModel();
if (theLinSOE == 0 || theModel == 0) {
opserr << "WARNING HHT_TP::newStep() - ";
opserr << "no LinearSOE or AnalysisModel has been set\n";
return -3;
}
// set the constants
c1 = 1.0;
c2 = gamma/(beta*deltaT);
c3 = 1.0/(beta*deltaT*deltaT);
if (U == 0) {
opserr << "HHTGeneralized_TP::newStep() - domainChange() failed or hasn't been called\n";
return -4;
}
// set response at t to be that at t+deltaT of previous step
(*Ut) = *U;
(*Utdot) = *Udot;
(*Utdotdot) = *Udotdot;
// get unbalance at t and store it
alphaM = (1.0 - alphaI);
alphaD = alphaR = alphaP = (1.0 - alphaF);
this->TransientIntegrator::formUnbalance();
(*Put) = theLinSOE->getB();
// 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;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "HHTGeneralized_TP::newStep() - failed to update the domain\n";
return -5;
}
// modify constants for subsequent iterations
alphaM = alphaI;
alphaD = alphaR = alphaP = alphaF;
return 0;
}
int
ArcLengthw::newStep(void)
{
ofstream factor;
factor.open("factor.dat",ios::app);
// get pointers to AnalysisModel and LinearSOE
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING ArcLengthw::newStep() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
// get the current load factor
currentLambda = theModel->getCurrentDomainTime();
factor<<"currentLambda"<<endln;
factor<<currentLambda<<endln;
// determine dUhat
this->formTangent();
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
Vector &dUhat = *deltaUhat;
factor<<"dUhat"<<endln;
//factor>>dUhat;
int size = dUhat.Size();
int i = 0;
double sum = 0.0;
int Ji_1 = 0;
double dLambda = 0.0;
factor<<"dWibefore"<<endln;
factor<<dWi<<endln;
factor<<"*phat"<<endln;
//factor>>*phat;
factor<<"dUhat"<<endln;
//factor>>dUhat;
factor<<"iFactor"<<endln;
factor<<iFactor<<endln;
factor<<"Jd"<<endln;
factor<<Jd<<endln;
factor<<"iflag"<<endln;
factor<<iflag<<endln;
double dJd = Jd;
double dJi_1 = 1.0;
if( iflag == 0 ){
dWi = ( (*phat) ^ dUhat ) * iFactor * iFactor;
dLambda = iFactor;
iflag = 1;
}
else if( iflag == 1 ){
Ji_1 = 10; //theAlgo->getNumIteration();
dJi_1 = Ji_1;
dWi = dWi * pow(( dJd / dJi_1 ),0.01);
dLambda = dWi / ( (*phat)^(dUhat) );
}
if( Ji_1 >0){
factor<<"Jd/Ji-1"<<endln;
factor<<dJd/dJi_1<<endln;
}
factor<<"iflag"<<endln;
factor<<iflag<<endln;
factor<<"Ji_1"<<endln;
factor<<Ji_1<<endln;
factor<<"dWi"<<endln;
factor<<dWi<<endln;
deltaLambdaStep = dLambda;
currentLambda += dLambda;
(*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
ArcLength::update(const Vector &dU)
{
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING ArcLength::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
(*deltaUbar) = dU; // have to do this as the SOE is gonna change
// determine dUhat
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
// determine the coeeficients of our quadratic equation
double a = alpha2 + ((*deltaUhat)^(*deltaUhat));
double b = alpha2*deltaLambdaStep
+ ((*deltaUhat)^(*deltaUbar))
+ ((*deltaUstep)^(*deltaUhat));
b *= 2.0;
double c = 2*((*deltaUstep)^(*deltaUbar)) + ((*deltaUbar)^(*deltaUbar));
// check for a solution to quadratic
double b24ac = b*b - 4.0*a*c;
if (b24ac < 0) {
opserr << "ArcLength::update() - imaginary roots due to multiple instability";
opserr << " directions - initial load increment was too large\n";
opserr << "a: " << a << " b: " << b << " c: " << c << " b24ac: " << b24ac << endln;
return -1;
}
double a2 = 2.0*a;
if (a2 == 0.0) {
opserr << "ArcLength::update() - zero denominator";
opserr << " alpha was set to 0.0 and zero reference load\n";
return -2;
}
// determine the roots of the quadratic
double sqrtb24ac = sqrt(b24ac);
double dlambda1 = (-b + sqrtb24ac)/a2;
double dlambda2 = (-b - sqrtb24ac)/a2;
double val = (*deltaUhat)^(*deltaUstep);
double theta1 = ((*deltaUstep)^(*deltaUstep)) + ((*deltaUbar)^(*deltaUstep));
// double theta2 = theta1 + dlambda2*val;
theta1 += dlambda1*val;
// choose dLambda based on angle between incremental displacement before
// and after this step -- want positive
double dLambda;
if (theta1 > 0)
dLambda = dlambda1;
else
dLambda = dlambda2;
// determine delta U(i)
(*deltaU) = (*deltaUbar);
deltaU->addVector(1.0, *deltaUhat,dLambda);
// update dU and dlambda
(*deltaUstep) += *deltaU;
deltaLambdaStep += dLambda;
currentLambda += dLambda;
// update the model
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
theModel->updateDomain();
// set the X soln in linearSOE to be deltaU for convergence Test
theLinSOE->setX(*deltaU);
return 0;
}
int
DisplacementPath::update(const Vector &dU)
{
// opserr << " update is invoked " << endln;
if (theDofID == -1) {
opserr << "DisplacementControl::newStep() - domainChanged has not been called\n";
return -1;
}
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING DisplacementPath::update() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
(*deltaUbar) = dU; // have to do this as the SOE is gonna change
double dUabar = (*deltaUbar)(theDofID);
// determine dUhat
theLinSOE->setB(*phat);
theLinSOE->solve();
(*deltaUhat) = theLinSOE->getX();
// add by zhong for check purpose
//int size = deltaUhat->Size();
//opserr << "\n size of deltaUhat = " << size << endln;
//for (int i=0; i<size; i++) {
// opserr << " dektaUhat(i) = " << (*deltaUhat)(i) << endln;
//}
// finish here
double dUahat = (*deltaUhat)(theDofID);
//opserr << " theDofID = " << theDofID << endln;
//opserr << "update( ) " << endln;
//opserr << "dUahat = " << dUahat << endln;
if (dUahat == 0.0) {
opserr << "WARNING DisplacementPath::update() ";
opserr << "dUahat is zero -- zero reference displacement at control node DOF\n";
return -1;
}
// determine delta lambda(1) == dlambda
double dLambda = -dUabar/dUahat;
// add by zhong
//opserr << "\n dUahat = " << dUahat << endln;
//opserr << " dUabar = " << dUabar << endln;
//opserr << " dLambda = " << dLambda << endln;
// finish
// determine delta U(i)
(*deltaU) = (*deltaUbar);
deltaU->addVector(1.0, *deltaUhat,dLambda);
// update dU and dlambda
(*deltaUstep) += *deltaU;
deltaLambdaStep += dLambda;
currentLambda += dLambda;
// update the model
theModel->incrDisp(*deltaU);
theModel->applyLoadDomain(currentLambda);
if (theModel->updateDomain() < 0) {
opserr << "DisplacementPath::update - model failed to update for new dU\n";
return -1;
}
// set the X soln in linearSOE to be deltaU for convergence Test
theLinSOE->setX(*deltaU);
return 0;
}
int KRAlphaExplicit::newStep(double _deltaT)
{
updateCount = 0;
if (beta == 0 || gamma == 0 ) {
opserr << "WARNING KRAlphaExplicit::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta = " << beta << endln;
return -1;
}
// get a pointer to the AnalysisModel
AnalysisModel *theModel = this->getAnalysisModel();
if (theModel == 0) {
opserr << "WARNING KRAlphaExplicit::newStep() - no AnalysisModel set\n";
return -2;
}
if (initAlphaMatrices || _deltaT != deltaT) {
// update time step increment
deltaT = _deltaT;
if (deltaT <= 0.0) {
opserr << "WARNING KRAlphaExplicit::newStep() - error in variable\n";
opserr << "dT = " << deltaT << endln;
return -3;
}
// get the LinearSOE and the ConvergenceTest so we can switch back later
LinearSOE *theLinSOE = this->getLinearSOE();
ConvergenceTest *theTest = this->getConvergenceTest();
// set up the FullLinearSOE (needed to compute the alpha matrices)
int size = theLinSOE->getNumEqn();
FullGenLinSolver *theFullLinSolver = new FullGenLinLapackSolver();
LinearSOE *theFullLinSOE = new FullGenLinSOE(size, *theFullLinSolver);
if (theFullLinSOE == 0) {
opserr << "WARNING KRAlphaExplicit::newStep() - failed to create FullLinearSOE\n";
return -4;
}
theFullLinSOE->setLinks(*theModel);
// now switch the SOE to the FullLinearSOE
this->IncrementalIntegrator::setLinks(*theModel, *theFullLinSOE, theTest);
// get a pointer to the A matrix of the FullLinearSOE
const Matrix *tmp = theFullLinSOE->getA();
if (tmp == 0) {
opserr << "WARNING KRAlphaExplicit::domainChanged() - ";
opserr << "failed to get A matrix of FullGeneral LinearSOE\n";
return -5;
}
// calculate the integration parameter matrices
c1 = beta*deltaT*deltaT;
c2 = gamma*deltaT;
c3 = 1.0;
this->TransientIntegrator::formTangent(INITIAL_TANGENT);
Matrix A(*tmp);
c1 *= (1.0 - alphaF);
c2 *= (1.0 - alphaF);
c3 = (1.0 -alphaM);
this->TransientIntegrator::formTangent(INITIAL_TANGENT);
Matrix B3(*tmp);
// solve [M + gamma*deltaT*C + beta*deltaT^2*K]*[alpha3] =
// [alphaM*M + alphaF*gamma*deltaT*C + alphaF*beta*deltaT^2*K] for alpha3
A.Solve(B3, *alpha3);
c1 = 0.0;
c2 = 0.0;
c3 = 1.0;
this->TransientIntegrator::formTangent(INITIAL_TANGENT);
Matrix B1(*tmp);
// solve [M + gamma*deltaT*C + beta*deltaT^2*K]*[alpha1] = [M] for alpha1
A.Solve(B1, *alpha1);
// calculate the effective mass matrix Mhat
Mhat->addMatrix(0.0, B1, 1.0);
Mhat->addMatrixProduct(1.0, B1, *alpha3, -1.0);
// switch the SOE back to the user specified one
this->IncrementalIntegrator::setLinks(*theModel, *theLinSOE, theTest);
initAlphaMatrices = 0;
}
if (U == 0) {
opserr << "WARNING KRAlphaExplicit::newStep() - domainChange() failed or hasn't been called\n";
return -6;
}
// 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 + gamma)*deltaT*deltaT
//U->addMatrixVector(1.0, *alpha1, *Utdotdot, a1);
//Udot->addMatrixVector(1.0, *alpha1, *Utdotdot, deltaT);
// determine new response at time t+deltaT
Utdothat->addMatrixVector(0.0, *alpha1, *Utdotdot, deltaT);
U->addVector(1.0, *Utdot, deltaT);
double a1 = (0.5 + gamma)*deltaT;
U->addVector(1.0, *Utdothat, a1);
Udot->addVector(1.0, *Utdothat, 1.0);
// determine the response at t+alpha*deltaT
Ualpha->addVector(0.0, *Ut, (1.0-alphaF));
Ualpha->addVector(1.0, *U, alphaF);
Ualphadot->addVector(0.0, *Utdot, (1.0-alphaF));
Ualphadot->addVector(1.0, *Udot, alphaF);
Ualphadotdot->addMatrixVector(0.0, *alpha3, *Utdotdot, 1.0);
// set the trial response quantities
theModel->setResponse(*Ualpha, *Ualphadot, *Ualphadotdot);
// increment the time to t+alpha*deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += alphaF*deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "WARNING KRAlphaExplicit::newStep() - failed to update the domain\n";
return -7;
}
return 0;
}
int
DisplacementControl::newStep(void)
{
if (theDofID == -1) {
opserr << "DisplacementControl::newStep() - domainChanged has not been called\n";
return -1;
}
// get pointers to AnalysisModel and LinearSOE
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING DisplacementControl::newStep() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
// determine increment for this iteration
double factor = specNumIncrStep/numIncrLastStep;
theIncrement *=factor;
if (theIncrement < minIncrement)
theIncrement = minIncrement;
else if (theIncrement > maxIncrement)
theIncrement = maxIncrement;
// get the current load factor
currentLambda = theModel->getCurrentDomainTime();
// determine dUhat
this->formTangent();
theLinSOE->setB(*phat);
if (theLinSOE->solve() < 0) {
opserr << "DisplacementControl::newStep(void) - failed in solver\n";
return -1;
}
(*deltaUhat) = theLinSOE->getX();
Vector &dUhat = *deltaUhat;
double dUahat = dUhat(theDofID);
if (dUahat == 0.0) {
opserr << "WARNING DisplacementControl::newStep() ";
opserr << "dUahat is zero -- zero reference displacement at control node DOF\n";
return -1;
}
// determine delta lambda(1) == dlambda
double dLambda = theIncrement/dUahat;
deltaLambdaStep = dLambda;
currentLambda += dLambda;
// opserr << "DisplacementControl: " << dUahat << " " << theDofID << endln;
// opserr << "DisplacementControl::newStep() : " << deltaLambdaStep << endln;
// 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);
if (theModel->updateDomain() < 0) {
opserr << "DisplacementControl::newStep - model failed to update for new dU\n";
return -1;
}
numIncrLastStep = 0;
return 0;
}
int
DisplacementPath::newStep(void)
{
if (theDofID == -1) {
opserr << "DisplacementPath::newStep() - domainChanged has not been called\n";
return -1;
}
// get pointers to AnalysisModel and LinearSOE
AnalysisModel *theModel = this->getAnalysisModel();
LinearSOE *theLinSOE = this->getLinearSOE();
if (theModel == 0 || theLinSOE == 0) {
opserr << "WARNING DisplacementPath::newStep() ";
opserr << "No AnalysisModel or LinearSOE has been set\n";
return -1;
}
// check theIncrementVector Vector
if ( theIncrementVector == 0 ) {
opserr << "DisplacementPath::newStep() - no theIncrementVector associated with object\n";
return -2;
}
// determine increment for this iteration
if (currentStep < theIncrementVector->Size()) {
theCurrentIncrement = (*theIncrementVector)(currentStep);
}
else {
theCurrentIncrement = 0.0;
opserr << "DisplacementPath::newStep() - reach the end of specified load path\n";
opserr << " - setting theCurrentIncrement = 0.0\n";
}
// get the current load factor
currentLambda = theModel->getCurrentDomainTime();
// determine dUhat and dUabar
this->formTangent();
this->formUnbalance();
(*deltaUbar) = theLinSOE->getX();
double dUabar = (*deltaUbar)(theDofID);
theLinSOE->setB(*phat);
if (theLinSOE->solve() < 0) {
opserr << "DisplacementControl::newStep(void) - failed in solver\n";
return -1;
}
(*deltaUhat) = theLinSOE->getX();
Vector &dUhat = *deltaUhat;
double dUahat = dUhat(theDofID);
//opserr << " newStep( ) " << endln;
//opserr << " theDofID = " << theDofID << endln;
//opserr << "dUahat = " << dUahat << endln;
if (dUahat == 0.0) {
opserr << "WARNING DisplacementPath::newStep() ";
opserr << "dUahat is zero -- zero reference displacement at control node DOF\n";
opserr << "currentStep = " << currentStep << endln; // add by zhong
opserr << " theCurrentIncrement = " << theCurrentIncrement << endln; // zhong
return -1;
}
// determine delta lambda(1) == dlambda
double dLambda = (theCurrentIncrement-dUabar)/dUahat;
deltaLambdaStep = dLambda;
currentLambda += dLambda;
// opserr << "DisplacementPath: " << dUahat << " " << theDofID << endln;
// opserr << "DisplacementPath::newStep() : " << deltaLambdaStep << endln;
// 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);
if (theModel->updateDomain() < 0) {
opserr << "DisplacementPath::newStep - model failed to update for new dU\n";
return -1;
}
currentStep++;
return 0;
}
int AlphaOSGeneralized::newStep(double _deltaT)
{
updateCount = 0;
deltaT = _deltaT;
if (beta == 0 || gamma == 0 ) {
opserr << "AlphaOSGeneralized::newStep() - error in variable\n";
opserr << "gamma = " << gamma << " beta = " << beta << endln;
return -1;
}
if (deltaT <= 0.0) {
opserr << "AlphaOSGeneralized::newStep() - error in variable\n";
opserr << "dT = " << deltaT << "\n";
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 << "AlphaOSGeneralized::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 displacements and velocities at time t+deltaT
U->addVector(1.0, *Utdot, deltaT);
double a1 = (0.5 - beta)*deltaT*deltaT;
U->addVector(1.0, *Utdotdot, a1);
double a2 = deltaT*(1.0 - gamma);
Udot->addVector(1.0, *Utdotdot, a2);
// determine the response at t+alphaF*deltaT
(*Ualpha) = *Upt;
Ualpha->addVector((1.0-alphaF), *U, alphaF);
(*Ualphadot) = *Utdot;
Ualphadot->addVector((1.0-alphaF), *Udot, alphaF);
Ualphadotdot->addVector(0.0, *Utdotdot, (1.0-alphaI));
// set the trial response quantities
theModel->setResponse(*Ualpha, *Ualphadot, *Ualphadotdot);
// increment the time to t+alphaF*deltaT and apply the load
double time = theModel->getCurrentDomainTime();
time += alphaF*deltaT;
if (theModel->updateDomain(time, deltaT) < 0) {
opserr << "AlphaOSGeneralized::newStep() - failed to update the domain\n";
return -4;
}
return 0;
}
