00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include "Teuchos_ParameterList.hpp"
00043 #include "LOCA_GlobalData.H"
00044 #include "LOCA_ErrorCheck.H"
00045 #include "LOCA_Parameter_Vector.H"
00046 #include "LOCA_MultiContinuation_AbstractGroup.H"
00047 #include "LOCA_MultiContinuation_ExtendedGroup.H"
00048 #include "LOCA_MultiContinuation_ConstrainedGroup.H"
00049 #include "LOCA_MultiPredictor_AbstractStrategy.H"
00050 #include "LOCA_Parameter_SublistParser.H"
00051 #include "LOCA_MultiContinuation_CompositeConstraint.H"
00052 #include "LOCA_MultiContinuation_CompositeConstraintMVDX.H"
00053
00054 LOCA::MultiContinuation::ExtendedGroup::ExtendedGroup(
00055 const LOCA::MultiContinuation::ExtendedGroup& source,
00056 NOX::CopyType type)
00057 : globalData(source.globalData),
00058 parsedParams(source.parsedParams),
00059 continuationParams(source.continuationParams),
00060 grpPtr(),
00061 predictor(),
00062 conGroup(),
00063 numParams(source.numParams),
00064 tangentMultiVec(source.tangentMultiVec, type),
00065 scaledTangentMultiVec(source.scaledTangentMultiVec, type),
00066 prevXVec(source.prevXVec, type),
00067 conParamIDs(source.conParamIDs),
00068 stepSize(source.stepSize),
00069 stepSizeScaleFactor(source.stepSizeScaleFactor),
00070 isValidPredictor(false),
00071 baseOnSecant(source.baseOnSecant)
00072 {
00073 predictor = source.predictor->clone(type);
00074 conGroup = Teuchos::rcp_dynamic_cast<LOCA::MultiContinuation::ConstrainedGroup>(source.conGroup->clone(type));
00075 grpPtr = conGroup->getGroup();
00076 if (source.isValidPredictor && type == NOX::DeepCopy)
00077 isValidPredictor = true;
00078 }
00079
00080
00081 LOCA::MultiContinuation::ExtendedGroup::~ExtendedGroup()
00082 {
00083 }
00084
00085 NOX::Abstract::Group&
00086 LOCA::MultiContinuation::ExtendedGroup::operator=(
00087 const NOX::Abstract::Group& source)
00088 {
00089 copy(source);
00090 return *this;
00091 }
00092
00093 Teuchos::RCP<NOX::Abstract::Group>
00094 LOCA::MultiContinuation::ExtendedGroup::clone(NOX::CopyType type) const
00095 {
00096 return Teuchos::rcp(new ExtendedGroup(*this, type));
00097 }
00098
00099 void
00100 LOCA::MultiContinuation::ExtendedGroup::setX(const NOX::Abstract::Vector& y)
00101 {
00102 conGroup->setX(y);
00103 }
00104
00105 void
00106 LOCA::MultiContinuation::ExtendedGroup::computeX(
00107 const NOX::Abstract::Group& g,
00108 const NOX::Abstract::Vector& d,
00109 double step)
00110 {
00111 const LOCA::MultiContinuation::ExtendedGroup& mg =
00112 dynamic_cast<const LOCA::MultiContinuation::ExtendedGroup&>(g);
00113
00114 conGroup->computeX(*(mg.conGroup), d, step);
00115 }
00116
00117 NOX::Abstract::Group::ReturnType
00118 LOCA::MultiContinuation::ExtendedGroup::computeF()
00119 {
00120 return conGroup->computeF();
00121 }
00122
00123 NOX::Abstract::Group::ReturnType
00124 LOCA::MultiContinuation::ExtendedGroup::computeJacobian()
00125 {
00126 return conGroup->computeJacobian();
00127 }
00128
00129 NOX::Abstract::Group::ReturnType
00130 LOCA::MultiContinuation::ExtendedGroup::computeGradient()
00131 {
00132 return conGroup->computeGradient();
00133 }
00134
00135 NOX::Abstract::Group::ReturnType
00136 LOCA::MultiContinuation::ExtendedGroup::computeNewton(
00137 Teuchos::ParameterList& params)
00138 {
00139 return conGroup->computeNewton(params);
00140 }
00141
00142 NOX::Abstract::Group::ReturnType
00143 LOCA::MultiContinuation::ExtendedGroup::applyJacobian(
00144 const NOX::Abstract::Vector& input,
00145 NOX::Abstract::Vector& result) const
00146 {
00147 return conGroup->applyJacobian(input, result);
00148 }
00149
00150 NOX::Abstract::Group::ReturnType
00151 LOCA::MultiContinuation::ExtendedGroup::applyJacobianTranspose(
00152 const NOX::Abstract::Vector& input,
00153 NOX::Abstract::Vector& result) const
00154 {
00155 return conGroup->applyJacobianTranspose(input, result);
00156 }
00157
00158 NOX::Abstract::Group::ReturnType
00159 LOCA::MultiContinuation::ExtendedGroup::applyJacobianInverse(
00160 Teuchos::ParameterList& params,
00161 const NOX::Abstract::Vector& input,
00162 NOX::Abstract::Vector& result) const
00163 {
00164 return conGroup->applyJacobianInverse(params, input, result);
00165 }
00166
00167 NOX::Abstract::Group::ReturnType
00168 LOCA::MultiContinuation::ExtendedGroup::applyJacobianMultiVector(
00169 const NOX::Abstract::MultiVector& input,
00170 NOX::Abstract::MultiVector& result) const
00171 {
00172 return conGroup->applyJacobianMultiVector(input, result);
00173 }
00174
00175 NOX::Abstract::Group::ReturnType
00176 LOCA::MultiContinuation::ExtendedGroup::applyJacobianTransposeMultiVector(
00177 const NOX::Abstract::MultiVector& input,
00178 NOX::Abstract::MultiVector& result) const
00179 {
00180 return conGroup->applyJacobianTransposeMultiVector(input, result);
00181 }
00182
00183 NOX::Abstract::Group::ReturnType
00184 LOCA::MultiContinuation::ExtendedGroup::applyJacobianInverseMultiVector(
00185 Teuchos::ParameterList& params,
00186 const NOX::Abstract::MultiVector& input,
00187 NOX::Abstract::MultiVector& result) const
00188 {
00189 return conGroup->applyJacobianInverseMultiVector(params, input, result);
00190 }
00191
00192 bool
00193 LOCA::MultiContinuation::ExtendedGroup::isF() const
00194 {
00195 return conGroup->isF();
00196 }
00197
00198 bool
00199 LOCA::MultiContinuation::ExtendedGroup::isJacobian() const
00200 {
00201 return conGroup->isJacobian();
00202 }
00203
00204 bool
00205 LOCA::MultiContinuation::ExtendedGroup::isGradient() const
00206 {
00207 return conGroup->isGradient();
00208 }
00209
00210 bool
00211 LOCA::MultiContinuation::ExtendedGroup::isNewton() const
00212 {
00213 return conGroup->isNewton();
00214 }
00215
00216 const NOX::Abstract::Vector&
00217 LOCA::MultiContinuation::ExtendedGroup::getX() const
00218 {
00219 return conGroup->getX();
00220 }
00221
00222 const NOX::Abstract::Vector&
00223 LOCA::MultiContinuation::ExtendedGroup::getF() const
00224 {
00225 return conGroup->getF();
00226 }
00227
00228 double
00229 LOCA::MultiContinuation::ExtendedGroup::getNormF() const
00230 {
00231 return conGroup->getNormF();
00232 }
00233
00234 const NOX::Abstract::Vector&
00235 LOCA::MultiContinuation::ExtendedGroup::getGradient() const
00236 {
00237 return conGroup->getGradient();
00238 }
00239
00240 const NOX::Abstract::Vector&
00241 LOCA::MultiContinuation::ExtendedGroup::getNewton() const
00242 {
00243 return conGroup->getNewton();
00244 }
00245
00246 double
00247 LOCA::MultiContinuation::ExtendedGroup::getNormNewtonSolveResidual() const
00248 {
00249 return conGroup->getNormNewtonSolveResidual();
00250 }
00251
00252 Teuchos::RCP<const LOCA::MultiContinuation::AbstractGroup>
00253 LOCA::MultiContinuation::ExtendedGroup::getUnderlyingGroup() const
00254 {
00255 return conGroup->getUnderlyingGroup();
00256 }
00257
00258 Teuchos::RCP<LOCA::MultiContinuation::AbstractGroup>
00259 LOCA::MultiContinuation::ExtendedGroup::getUnderlyingGroup()
00260 {
00261 return conGroup->getUnderlyingGroup();
00262 }
00263
00264 void
00265 LOCA::MultiContinuation::ExtendedGroup::copy(const NOX::Abstract::Group& src)
00266 {
00267
00268 const LOCA::MultiContinuation::ExtendedGroup& source =
00269 dynamic_cast<const LOCA::MultiContinuation::ExtendedGroup&>(src);
00270
00271
00272 if (this != &source) {
00273 globalData = source.globalData;
00274 parsedParams = source.parsedParams;
00275 continuationParams = source.continuationParams;
00276 *predictor = *source.predictor;
00277 conGroup->copy(*source.conGroup);
00278 grpPtr = conGroup->getGroup();
00279 numParams = source.numParams;
00280 tangentMultiVec = source.tangentMultiVec;
00281 scaledTangentMultiVec = source.scaledTangentMultiVec;
00282 prevXVec = source.prevXVec;
00283 conParamIDs = source.conParamIDs;
00284 stepSize = source.stepSize;
00285 stepSizeScaleFactor = source.stepSizeScaleFactor;
00286 isValidPredictor = source.isValidPredictor;
00287 baseOnSecant = source.baseOnSecant;
00288 }
00289 }
00290
00291 int
00292 LOCA::MultiContinuation::ExtendedGroup::getNumParams() const
00293 {
00294 return numParams;
00295 }
00296
00297 void
00298 LOCA::MultiContinuation::ExtendedGroup::preProcessContinuationStep(
00299 LOCA::Abstract::Iterator::StepStatus stepStatus)
00300 {
00301 conGroup->preProcessContinuationStep(stepStatus);
00302 }
00303
00304 void
00305 LOCA::MultiContinuation::ExtendedGroup::postProcessContinuationStep(
00306 LOCA::Abstract::Iterator::StepStatus stepStatus)
00307 {
00308 conGroup->postProcessContinuationStep(stepStatus);
00309 if (stepStatus == LOCA::Abstract::Iterator::Successful) {
00310 isValidPredictor = false;
00311 baseOnSecant = true;
00312 }
00313 }
00314
00315 NOX::Abstract::Group::ReturnType
00316 LOCA::MultiContinuation::ExtendedGroup::computePredictor()
00317 {
00318 if (isValidPredictor)
00319 return NOX::Abstract::Group::Ok;
00320
00321 string callingFunction =
00322 "LOCA::MultiContinuation::ExtendedGroup::computePredictor()";
00323 NOX::Abstract::Group::ReturnType status;
00324 NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
00325
00326
00327 status = predictor->compute(baseOnSecant, stepSize, *this, prevXVec,
00328 dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(conGroup->
00329 getX()));
00330 finalStatus =
00331 globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
00332 callingFunction);
00333
00334
00335 status = predictor->computeTangent(tangentMultiVec);
00336 finalStatus =
00337 globalData->locaErrorCheck->combineAndCheckReturnTypes(status, finalStatus,
00338 callingFunction);
00339
00340 scaleTangent();
00341
00342 isValidPredictor = true;
00343 return finalStatus;
00344 }
00345
00346 bool
00347 LOCA::MultiContinuation::ExtendedGroup::isPredictor() const
00348 {
00349 return isValidPredictor;
00350 }
00351
00352 void
00353 LOCA::MultiContinuation::ExtendedGroup::scaleTangent()
00354 {
00355 LOCA::MultiContinuation::ExtendedVector *v;
00356
00357 scaledTangentMultiVec = tangentMultiVec;
00358
00359
00360 if (predictor->isTangentScalable()) {
00361
00362 for (int i=0; i<numParams; i++) {
00363 v =
00364 dynamic_cast<LOCA::MultiContinuation::ExtendedVector*>(&scaledTangentMultiVec[i]);
00365 grpPtr->scaleVector(*(v->getXVec()));
00366 grpPtr->scaleVector(*(v->getXVec()));
00367 }
00368
00369 }
00370 }
00371
00372 void
00373 LOCA::MultiContinuation::ExtendedGroup::setPredictorTangentDirection(
00374 const LOCA::MultiContinuation::ExtendedVector& v,
00375 int i)
00376 {
00377 tangentMultiVec[i] = v;
00378 }
00379
00380 const LOCA::MultiContinuation::ExtendedMultiVector&
00381 LOCA::MultiContinuation::ExtendedGroup::getPredictorTangent() const
00382 {
00383 return tangentMultiVec;
00384 }
00385
00386
00387 const LOCA::MultiContinuation::ExtendedMultiVector&
00388 LOCA::MultiContinuation::ExtendedGroup::getScaledPredictorTangent() const
00389 {
00390 return scaledTangentMultiVec;
00391 }
00392
00393 void
00394 LOCA::MultiContinuation::ExtendedGroup::setPrevX(
00395 const NOX::Abstract::Vector& y)
00396 {
00397 prevXVec = y;
00398 }
00399
00400 const LOCA::MultiContinuation::ExtendedVector&
00401 LOCA::MultiContinuation::ExtendedGroup::getPrevX() const
00402 {
00403 return prevXVec;
00404 }
00405
00406 void
00407 LOCA::MultiContinuation::ExtendedGroup::setStepSize(double deltaS, int i)
00408 {
00409 stepSize[i] = deltaS;
00410 }
00411
00412 double
00413 LOCA::MultiContinuation::ExtendedGroup::getStepSize(int i) const
00414 {
00415 return stepSize[i];
00416 }
00417
00418 void
00419 LOCA::MultiContinuation::ExtendedGroup::setContinuationParameter(double val,
00420 int i)
00421 {
00422 conGroup->setConstraintParameter(i, val);
00423 }
00424
00425 double
00426 LOCA::MultiContinuation::ExtendedGroup::getContinuationParameter(int i) const
00427 {
00428 return conGroup->getConstraintParameter(i);
00429 }
00430
00431 int
00432 LOCA::MultiContinuation::ExtendedGroup::getContinuationParameterID(int i) const
00433 {
00434 return conParamIDs[i];
00435 }
00436
00437 const vector<int>&
00438 LOCA::MultiContinuation::ExtendedGroup::getContinuationParameterIDs() const
00439 {
00440 return conParamIDs;
00441 }
00442
00443 string
00444 LOCA::MultiContinuation::ExtendedGroup::getContinuationParameterName(
00445 int i) const
00446 {
00447 const LOCA::ParameterVector& p = grpPtr->getParams();
00448 return p.getLabel(conParamIDs[i]);
00449 }
00450
00451 double
00452 LOCA::MultiContinuation::ExtendedGroup::getStepSizeScaleFactor(int i) const
00453 {
00454 return stepSizeScaleFactor[i];
00455 }
00456
00457 void
00458 LOCA::MultiContinuation::ExtendedGroup::printSolution() const
00459 {
00460 for (int i=0; i<numParams; i++)
00461 grpPtr->printSolution(getContinuationParameter(i));
00462 }
00463
00464 double
00465 LOCA::MultiContinuation::ExtendedGroup::computeScaledDotProduct(
00466 const NOX::Abstract::Vector& x,
00467 const NOX::Abstract::Vector& y) const
00468 {
00469 const LOCA::MultiContinuation::ExtendedVector& mx =
00470 dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(x);
00471 const LOCA::MultiContinuation::ExtendedVector& my =
00472 dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(y);
00473
00474 double val = grpPtr->computeScaledDotProduct(*mx.getXVec(), *my.getXVec());
00475 for (int i=0; i<numParams; i++)
00476 val += mx.getScalar(i) * my.getScalar(i);
00477
00478 return val;
00479 }
00480
00481 int
00482 LOCA::MultiContinuation::ExtendedGroup::projectToDrawDimension() const
00483 {
00484 return numParams + grpPtr->projectToDrawDimension();
00485 }
00486
00487 void
00488 LOCA::MultiContinuation::ExtendedGroup::projectToDraw(
00489 const LOCA::MultiContinuation::ExtendedVector& x,
00490 double *px) const
00491 {
00492
00493 for (int i=0; i<numParams; i++)
00494 px[i] = x.getScalar(i);
00495
00496
00497 grpPtr->projectToDraw(*x.getXVec(), px+numParams);
00498 }
00499
00500 int
00501 LOCA::MultiContinuation::ExtendedGroup::getBorderedWidth() const
00502 {
00503 return conGroup->getBorderedWidth();
00504 }
00505
00506 Teuchos::RCP<const NOX::Abstract::Group>
00507 LOCA::MultiContinuation::ExtendedGroup::getUnborderedGroup() const
00508 {
00509 return conGroup->getUnborderedGroup();
00510 }
00511
00512 bool
00513 LOCA::MultiContinuation::ExtendedGroup::isCombinedAZero() const
00514 {
00515 return conGroup->isCombinedAZero();
00516 }
00517
00518 bool
00519 LOCA::MultiContinuation::ExtendedGroup::isCombinedBZero() const
00520 {
00521 return conGroup->isCombinedBZero();
00522 }
00523
00524 bool
00525 LOCA::MultiContinuation::ExtendedGroup::isCombinedCZero() const
00526 {
00527 return conGroup->isCombinedCZero();
00528 }
00529
00530 void
00531 LOCA::MultiContinuation::ExtendedGroup::extractSolutionComponent(
00532 const NOX::Abstract::MultiVector& v,
00533 NOX::Abstract::MultiVector& v_x) const
00534 {
00535 conGroup->extractSolutionComponent(v, v_x);
00536 }
00537
00538 void
00539 LOCA::MultiContinuation::ExtendedGroup::extractParameterComponent(
00540 bool use_transpose,
00541 const NOX::Abstract::MultiVector& v,
00542 NOX::Abstract::MultiVector::DenseMatrix& v_p) const
00543 {
00544 conGroup->extractParameterComponent(use_transpose, v, v_p);
00545 }
00546
00547 void
00548 LOCA::MultiContinuation::ExtendedGroup::loadNestedComponents(
00549 const NOX::Abstract::MultiVector& v_x,
00550 const NOX::Abstract::MultiVector::DenseMatrix& v_p,
00551 NOX::Abstract::MultiVector& v) const
00552 {
00553 conGroup->loadNestedComponents(v_x, v_p, v);
00554 }
00555
00556 void
00557 LOCA::MultiContinuation::ExtendedGroup::fillA(
00558 NOX::Abstract::MultiVector& A) const
00559 {
00560 conGroup->fillA(A);
00561 }
00562
00563 void
00564 LOCA::MultiContinuation::ExtendedGroup::fillB(
00565 NOX::Abstract::MultiVector& B) const
00566 {
00567 conGroup->fillB(B);
00568 }
00569
00570 void
00571 LOCA::MultiContinuation::ExtendedGroup::fillC(
00572 NOX::Abstract::MultiVector::DenseMatrix& C) const
00573 {
00574 conGroup->fillC(C);
00575 }
00576
00577 LOCA::MultiContinuation::ExtendedGroup::ExtendedGroup(
00578 const Teuchos::RCP<LOCA::GlobalData>& global_data,
00579 const Teuchos::RCP<LOCA::Parameter::SublistParser>& topParams,
00580 const Teuchos::RCP<Teuchos::ParameterList>& conParams,
00581 const Teuchos::RCP<LOCA::MultiContinuation::AbstractGroup>& grp,
00582 const Teuchos::RCP<LOCA::MultiPredictor::AbstractStrategy>& pred,
00583 const vector<int>& paramIDs)
00584 : globalData(global_data),
00585 parsedParams(topParams),
00586 continuationParams(conParams),
00587 grpPtr(grp),
00588 predictor(pred),
00589 conGroup(),
00590 numParams(paramIDs.size()),
00591 tangentMultiVec(globalData, grp->getX(), numParams, numParams,
00592 NOX::ShapeCopy),
00593 scaledTangentMultiVec(globalData, grp->getX(), numParams, numParams,
00594 NOX::ShapeCopy),
00595 prevXVec(globalData, grp->getX(), numParams),
00596 conParamIDs(paramIDs),
00597 stepSize(numParams, 0.0),
00598 stepSizeScaleFactor(numParams, 1.0),
00599 isValidPredictor(false),
00600 baseOnSecant(false)
00601 {
00602 }
00603
00604 void
00605 LOCA::MultiContinuation::ExtendedGroup::setConstraints(const Teuchos::RCP<LOCA::MultiContinuation::ConstraintInterface>& constraints, bool skip_dfdp)
00606 {
00607
00608 conGroup = Teuchos::rcp(new ConstrainedGroup(globalData, parsedParams,
00609 continuationParams,
00610 grpPtr, constraints,
00611 conParamIDs,
00612 skip_dfdp));
00613 grpPtr = conGroup->getGroup();
00614 }