int
Linear::solveCurrentStep(void)
{
// set up some pointers and check they are valid
// NOTE this could be taken away if we set Ptrs as protecetd in superclass
AnalysisModel *theAnalysisModel = this->getAnalysisModelPtr();
LinearSOE *theSOE = this->getLinearSOEptr();
IncrementalIntegrator *theIncIntegrator =
this->getIncrementalIntegratorPtr();
if ((theAnalysisModel == 0) || (theIncIntegrator ==0 ) || (theSOE == 0)) {
opserr << "WARNING Linear::solveCurrentStep() -";
opserr << "setLinks() has not been called.\n";
return -5;
}
if (factorOnce != 2) {
if (theIncIntegrator->formTangent(incrTangent) < 0) {
opserr << "WARNING Linear::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
if (factorOnce == 1)
factorOnce = 2;
}
if (theIncIntegrator->formUnbalance() < 0) {
opserr << "WARNING Linear::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
if (theSOE->solve() < 0) {
opserr << "WARNING Linear::solveCurrentStep() -";
opserr << "the LinearSOE failed in solve()\n";
return -3;
}
const Vector &deltaU = theSOE->getX();
if (theIncIntegrator->update(deltaU) < 0) {
opserr << "WARNING Linear::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
return 0;
}
int
SecantAccelerator2::updateTangent(IncrementalIntegrator &theIntegrator)
{
if (iteration < maxIterations)
return 0;
switch (theTangent) {
case CURRENT_TANGENT:
iteration = 0;
theIntegrator.formTangent(CURRENT_TANGENT);
return 1;
break;
case INITIAL_TANGENT:
iteration = 0;
theIntegrator.formTangent(INITIAL_TANGENT);
return 0;
break;
case NO_TANGENT:
//iteration = 0;
return 0;
break;
default:
return 0;
}
/*
if (iteration > maxIterations) {
//opserr << "SecantAccelerator2::updateTangent() tangent formed" << endln;
iteration = 0;
if (theTangent != NO_TANGENT) {
theIntegrator.formTangent(theTangent);
if (theTangent == CURRENT_TANGENT)
return 1;
else
return 0;
}
else
return 0;
}
else
return 0;
*/
}
int
MillerAccelerator::updateTangent(IncrementalIntegrator &theIntegrator)
{
/*
if (dimension >= maxDimension) {
dimension = 0;
if (theTangent != NO_TANGENT) {
iteration = 1; // reset Newton iteration if tangent is formed
theIntegrator.formTangent(theTangent);
//opserr << "MillerAccelerator::updateTangent() tangent formed" << endln;
return 1;
}
else
return 0;
}
else
return 0;
*/
if (dimension < maxDimension)
return 0;
switch (theTangent) {
case CURRENT_TANGENT:
iteration = 1;
dimension = 0;
theIntegrator.formTangent(CURRENT_TANGENT);
return 1;
break;
case INITIAL_TANGENT:
dimension = 0;
theIntegrator.formTangent(INITIAL_TANGENT);
return 0;
break;
case NO_TANGENT:
dimension = 0;
return 0;
break;
default:
return 0;
}
}
int
ShadowSubdomain::setAnalysisIntegrator(IncrementalIntegrator &theIntegrator)
{
msgData(0) = ShadowActorSubdomain_setAnalysisIntegrator;
msgData(1) = theIntegrator.getClassTag();
this->sendID(msgData);
this->sendObject(theIntegrator);
this->recvID(msgData);
return 0;
}
int
RaphsonAccelerator::updateTangent(IncrementalIntegrator &theIntegrator)
{
/*
if (theTangent == NO_TANGENT)
return 0;
else if (theTangent == SECOND_TANGENT) {
if (totalIter == 1) {
theIntegrator.formTangent(CURRENT_TANGENT);
return 1;
}
else
return 0;
}
else { // CURRENT_TANGENT or INITIAL_TANGENT
theIntegrator.formTangent(theTangent);
return 1;
}
*/
switch (theTangent) {
case CURRENT_TANGENT:
theIntegrator.formTangent(CURRENT_TANGENT);
return 1;
break;
case INITIAL_TANGENT:
theIntegrator.formTangent(INITIAL_TANGENT);
return 0;
break;
default:
return 0;
break;
}
}
int
KrylovAccelerator2::updateTangent(IncrementalIntegrator &theIntegrator)
{
if (dimension > maxDimension) {
dimension = 0;
if (theTangent != NO_TANGENT) {
//opserr << "KrylovAccelerator2::updateTangent() tangent formed" << endln;
theIntegrator.formTangent(theTangent);
return 1;
}
else
return 0;
}
else
return 0;
}
int
BFGS::solveCurrentStep(void)
{
// set up some pointers and check they are valid
// NOTE this could be taken away if we set Ptrs as protecetd in superclass
AnalysisModel *theAnaModel = this->getAnalysisModelPtr();
IncrementalIntegrator *theIntegrator = this->getIncrementalIntegratorPtr();
LinearSOE *theSOE = this->getLinearSOEptr();
if ((theAnaModel == 0) || (theIntegrator == 0) || (theSOE == 0)
|| (theTest == 0)){
opserr << "WARNING BFGS::solveCurrentStep() - setLinks() has";
opserr << " not been called - or no ConvergenceTest has been set\n";
return -5;
}
// set itself as the ConvergenceTest objects EquiSolnAlgo
theTest->setEquiSolnAlgo(*this);
if (theTest->start() < 0) {
opserr << "BFGS::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in start()\n";
return -3;
}
localTest->setEquiSolnAlgo(*this);
if (rdotz == 0)
rdotz = new double[numberLoops+3];
if (sdotr == 0)
sdotr = new double[numberLoops+3];
int result = -1;
int count = 0;
do {
// opserr << " BFGS -- Forming New Tangent" << endln;
//form the initial tangent
if (theIntegrator->formTangent(tangent) < 0){
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
//form the initial residual
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
}
//solve
if (theSOE->solve() < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the LinearSysOfEqn failed in solve()\n";
return -3;
}
//update
if ( theIntegrator->update(theSOE->getX() ) < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
// int systemSize = ( theSOE->getB() ).Size();
int systemSize = theSOE->getNumEqn( );
//temporary vector
if (temp == 0 )
temp = new Vector(systemSize);
//initial displacement increment
if ( s[1] == 0 )
s[1] = new Vector(systemSize);
*s[1] = theSOE->getX( );
if ( residOld == 0 )
residOld = new Vector(systemSize);
*residOld = theSOE->getB( ) ;
*residOld *= (-1.0 );
//form the residual again
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
}
if ( residNew == 0 )
residNew = new Vector(systemSize);
if ( du == 0 )
du = new Vector(systemSize);
if ( b == 0 )
b = new Vector(systemSize);
localTest->start();
int nBFGS = 1;
do {
//save residual
*residNew = theSOE->getB( );
*residNew *= (-1.0 );
//solve
if (theSOE->solve() < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the LinearSysOfEqn failed in solve()\n";
return -3;
}
//save right hand side
*b = theSOE->getB( );
//save displacement increment
*du = theSOE->getX( );
//BFGS modifications to du
BFGSUpdate( theIntegrator, theSOE, *du, *b, nBFGS ) ;
if ( theIntegrator->update( *du ) < 0 ) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
/* opserr << " BFGS Iteration " << nBFGS
<< " Residual Norm = "
<< sqrt( (*residNew) ^ (*residNew) ) << endln;
*/
//increment broyden counter
nBFGS += 1;
//save displacement increment
if ( s[nBFGS] == 0 )
s[nBFGS] = new Vector(systemSize);
*s[nBFGS] = *du;
//swap residuals
*residOld = *residNew;
//form the residual again
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING BFGS::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
}
result = localTest->test();
} while ( result == -1 && nBFGS <= numberLoops );
result = theTest->test();
this->record(count++);
} while (result == -1);
if (result == -2) {
opserr << "BFGS::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in test()\n";
return -3;
}
// note - if postive result we are returning what the convergence test returned
// which should be the number of iterations
return result;
}
int
SecantLineSearch::search(double s0,
double s1,
LinearSOE &theSOE,
IncrementalIntegrator &theIntegrator)
{
double r0 = 0.0;
if ( s0 != 0.0 )
r0 = fabs( s1 / s0 );
if (r0 <= tolerance )
return 0; // Line Search Not Required Residual Decrease Less Than Tolerance
if (s1 == s0)
return 0; // Secant will have a divide-by-zero if continue
// set some variables
double eta = 1.0;
double s = s1;
double etaJ = 1.0;
double etaJm1 = 0.0;
double sJ = s1;
double sJm1 = s0;
double r = r0;
const Vector &dU = theSOE.getX();
if (printFlag == 0) {
opserr << "Secant Line Search - initial: "
<< " eta(0) : " << eta << " , Ratio |s/s0| = " << r0 << endln;
}
// perform the secant iterations:
//
// eta(j+1) = eta(j) - s(j) * (eta(j-1)-eta(j))
// ------------------------
// s(j-1) - s(j)
int count = 0; //intial value of iteration counter
while ( r > tolerance && count < maxIter ) {
count++;
eta = etaJ - sJ * (etaJm1-etaJ) / (sJm1 - sJ);
//-- want to put limits on eta and stop solution blowing up
if (eta > maxEta) eta = maxEta;
if (r > r0 ) eta = 1.0;
if (eta < minEta) eta = minEta;
//update the incremental difference in response and determine new unbalance
if (eta == etaJ)
break; // no change in response
*x = dU;
*x *= eta-etaJ;
if (theIntegrator.update(*x) < 0) {
opserr << "WARNING SecantLineSearch::search() -";
opserr << "the Integrator failed in update()\n";
return -1;
}
if (theIntegrator.formUnbalance() < 0) {
opserr << "WARNING SecantLineSearch::search() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
//new residual
const Vector &ResidJ = theSOE.getB();
//new value of s
s = dU ^ ResidJ;
//new value of r
r = fabs( s / s0 );
if (printFlag == 0) {
opserr << "Secant Line Search - iteration: " << count
<< " , eta(j) : " << eta << " , Ratio |sj/s0| = " << r << endln;
}
if (etaJ == eta)
count = maxIter;
// set variables for next iteration
etaJm1 = etaJ;
etaJ = eta;
sJm1 = sJ;
sJ = s;
if (sJm1 == sJ)
count = maxIter;
} //end while
// set X in the SOE for the revised dU, needed for convergence tests
*x = dU;
if (eta != 0.0)
*x *= eta;
theSOE.setX(*x);
return 0;
}
int
NewtonLineSearch::solveCurrentStep(void)
{
// set up some pointers and check they are valid
// NOTE this could be taken away if we set Ptrs as protecetd in superclass
AnalysisModel *theAnaModel = this->getAnalysisModelPtr();
IncrementalIntegrator *theIntegrator = this->getIncrementalIntegratorPtr();
LinearSOE *theSOE = this->getLinearSOEptr();
if ((theAnaModel == 0) || (theIntegrator == 0) || (theSOE == 0)
|| (theTest == 0)){
opserr << "WARNING NewtonLineSearch::solveCurrentStep() - setLinks() has";
opserr << " not been called - or no ConvergenceTest has been set\n";
return -5;
}
theLineSearch->newStep(*theSOE);
// set itself as the ConvergenceTest objects EquiSolnAlgo
theTest->setEquiSolnAlgo(*this);
if (theTest->start() < 0) {
opserr << "NewtonLineSearch::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in start()\n";
return -3;
}
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING NewtonLineSearch::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
int result = -1;
do {
//residual at this iteration before next solve
const Vector &Resid0 = theSOE->getB() ;
//form the tangent
if (theIntegrator->formTangent() < 0){
opserr << "WARNING NewtonLineSearch::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
//solve
if (theSOE->solve() < 0) {
opserr << "WARNING NewtonLineSearch::solveCurrentStep() -";
opserr << "the LinearSysOfEqn failed in solve()\n";
return -3;
}
//line search direction
const Vector &dx0 = theSOE->getX() ;
//intial value of s
double s0 = - (dx0 ^ Resid0) ;
if (theIntegrator->update(theSOE->getX()) < 0) {
opserr << "WARNING NewtonLineSearch::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING NewtonLineSearch::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
// do a line search only if convergence criteria not met
theOtherTest->start();
result = theOtherTest->test();
if (result < 1) {
//new residual
const Vector &Resid = theSOE->getB() ;
//new value of s
double s = - ( dx0 ^ Resid ) ;
if (theLineSearch != 0)
theLineSearch->search(s0, s, *theSOE, *theIntegrator);
}
this->record(0);
result = theTest->test();
} while (result == -1);
if (result == -2) {
opserr << "NewtonLineSearch::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in test()\n";
return -3;
}
// note - if postive result we are returning what the convergence test returned
// which should be the number of iterations
return result;
}
int
NewtonRaphson::solveCurrentStep(void)
{
// set up some pointers and check they are valid
// NOTE this could be taken away if we set Ptrs as protecetd in superclass
AnalysisModel *theAnaModel = this->getAnalysisModelPtr();
IncrementalIntegrator *theIntegrator = this->getIncrementalIntegratorPtr();
LinearSOE *theSOE = this->getLinearSOEptr();
if ((theAnaModel == 0) || (theIntegrator == 0) || (theSOE == 0)
|| (theTest == 0)){
opserr << "WARNING NewtonRaphson::solveCurrentStep() - setLinks() has";
opserr << " not been called - or no ConvergenceTest has been set\n";
return -5;
}
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
// set itself as the ConvergenceTest objects EquiSolnAlgo
theTest->setEquiSolnAlgo(*this);
if (theTest->start() < 0) {
opserr << "NewtnRaphson::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in start()\n";
return -3;
}
int result = -1;
int count = 0;
do {
if (tangent == INITIAL_THEN_CURRENT_TANGENT) {
if (count == 0) {
if (theIntegrator->formTangent(INITIAL_TANGENT) < 0){
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
} else {
if (theIntegrator->formTangent(CURRENT_TANGENT) < 0){
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
}
} else {
if (theIntegrator->formTangent(tangent) < 0){
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
}
if (theSOE->solve() < 0) {
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the LinearSysOfEqn failed in solve()\n";
return -3;
}
if (theIntegrator->update(theSOE->getX()) < 0) {
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
if (theIntegrator->formUnbalance() < 0) {
opserr << "WARNING NewtonRaphson::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
result = theTest->test();
this->record(count++);
} while (result == -1);
if (result == -2) {
opserr << "NewtnRaphson::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in test()\n";
return -3;
}
// note - if postive result we are returning what the convergence test returned
// which should be the number of iterations
return result;
}
int
PeriodicNewton::solveCurrentStep(void)
{
// set up some pointers and check they are valid
// NOTE this could be taken away if we set Ptrs as protecetd in superclass
AnalysisModel *theAnalysisModel = this->getAnalysisModelPtr();
IncrementalIntegrator *theIncIntegratorr = this->getIncrementalIntegratorPtr();
LinearSOE *theSOE = this->getLinearSOEptr();
if ((theAnalysisModel == 0) || (theIncIntegratorr == 0) || (theSOE == 0)
|| (theTest == 0)){
opserr << "WARNING PeriodicNewton::solveCurrentStep() - setLinks() has";
opserr << " not been called - or no ConvergenceTest has been set\n";
return -5;
}
// we form the tangent
if (theIncIntegratorr->formUnbalance() < 0) {
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
if (theIncIntegratorr->formTangent(tangent) < 0){
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
// set itself as the ConvergenceTest objects EquiSolnAlgo
theTest->setEquiSolnAlgo(*this);
if (theTest->start() < 0) {
opserr << "PeriodicNewton::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in start()\n";
return -3;
}
// repeat until convergence is obtained or reach max num iterations
int result = -1;
int count = 0;
int iter = 0;
do {
if (theSOE->solve() < 0) {
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the LinearSysOfEqn failed in solve()\n";
return -3;
}
if (theIncIntegratorr->update(theSOE->getX()) < 0) {
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the Integrator failed in update()\n";
return -4;
}
if (theIncIntegratorr->formUnbalance() < 0) {
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
this->record(count++);
result = theTest->test();
iter++;
if (iter > maxCount) {
if (theIncIntegratorr->formTangent(tangent) < 0){
opserr << "WARNING PeriodicNewton::solveCurrentStep() -";
opserr << "the Integrator failed in formTangent()\n";
return -1;
}
iter = 0;
}
} while (result == -1);
if (result == -2) {
opserr << "PeriodicNewton::solveCurrentStep() -";
opserr << "the ConvergenceTest object failed in test()\n";
return -3;
}
return result;
}
int
InitialInterpolatedLineSearch::search(double s0,
double s1,
LinearSOE &theSOE,
IncrementalIntegrator &theIntegrator)
{
double s = s1;
//intialize r = ratio of residuals
double r0 = 0.0;
if ( s0 != 0.0 )
r0 = fabs( s / s0 );
if (r0 <= tolerance )
return 0; // Line Search Not Required Residual Decrease Less Than Tolerance
double eta = 1.0; //initial value of line search parameter
double etaPrev = 1.0;
double r = r0;
const Vector &dU = theSOE.getX();
int count = 0; //intial value of iteration counter
if (printFlag == 0) {
opserr << "InitialInterpolated Line Search - initial "
<< " eta : " << eta
<< " , Ratio |s/s0| = " << r0 << endln;
}
// Solution procedure follows the one in Crissfields book.
// (M.A. Crissfield, Nonlinear Finite Element Analysis of Solid and Structures, Wiley. 97).
// NOTE: it is not quite linear interpolation/false-position/regula-falsi as eta(0) = 0.0
// does not change. uses eta(i) = eta(i-1)*s0
// -----------
// s0 - s(i-1) to compute eta(i)
// opserr << "dU: " << dU;
while ( r > tolerance && count < maxIter ) {
count++;
eta *= s0 / (s0 - s);
//-- want to put limits on eta(i)
if (eta > maxEta) eta = maxEta;
if (r > r0 ) eta = 1.0;
if (eta < minEta) eta = minEta;
if (eta == etaPrev)
break; // no change in response break
//dx = ( eta * dx0 );
*x = dU;
*x *= eta-etaPrev;
if (theIntegrator.update(*x) < 0) {
opserr << "WARNInG InitialInterpolatedLineSearch::search() -";
opserr << "the Integrator failed in update()\n";
return -1;
}
if (theIntegrator.formUnbalance() < 0) {
opserr << "WARNInG InitialInterpolatedLineSearch::search() -";
opserr << "the Integrator failed in formUnbalance()\n";
return -2;
}
//new residual
const Vector &ResidI = theSOE.getB();
//new value of s
s = dU ^ ResidI;
//new value of r
r = fabs( s / s0 );
if (printFlag == 0) {
opserr << "InitialInterpolated Line Search - iteration: " << count
<< " , eta(j) : " << eta
<< " , Ratio |sj/s0| = " << r << endln;
}
// reset the variables, also check not just hitting bounds over and over
if (eta == etaPrev)
count = maxIter;
else
etaPrev = eta;
} //end while
// set X in the SOE for the revised dU, needed for convergence tests
*x = dU;
if (eta != 0.0)
*x *= eta;
theSOE.setX(*x);
return 0;
}
