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 "LOCA_Epetra_Group.H"
00043
00044 #include "LOCA_Epetra_Interface_Required.H"
00045 #include "Teuchos_ParameterList.hpp"
00046 #include "Epetra_Map.h"
00047 #include "Epetra_Vector.h"
00048 #include "Epetra_CrsMatrix.h"
00049 #include "Epetra_VbrMatrix.h"
00050 #include "LOCA_Epetra_ShiftInvertOperator.H"
00051 #include "AztecOO.h"
00052 #include "NOX_Epetra_LinearSystem_AztecOO.H"
00053 #include "LOCA_Epetra_TransposeLinearSystem_AbstractStrategy.H"
00054 #include "LOCA_Epetra_TransposeLinearSystem_Factory.H"
00055 #include "LOCA_GlobalData.H"
00056 #include "LOCA_ErrorCheck.H"
00057 #include "NOX_Epetra_MultiVector.H"
00058 #include "LOCA_Parameter_SublistParser.H"
00059
00060 #ifdef HAVE_NOX_EPETRAEXT
00061 #include "EpetraExt_BlockCrsMatrix.h"
00062 #include "EpetraExt_BlockVector.h"
00063 #include "EpetraExt_BlockMultiVector.h"
00064 #endif
00065
00066 LOCA::Epetra::Group::Group(
00067 const Teuchos::RCP<LOCA::GlobalData>& global_data,
00068 Teuchos::ParameterList& printingParams,
00069 const Teuchos::RCP<LOCA::Epetra::Interface::Required>& i,
00070 NOX::Epetra::Vector& initialGuess,
00071 const LOCA::ParameterVector& p) :
00072 NOX::Epetra::Group(printingParams, i, initialGuess),
00073 LOCA::Abstract::Group(global_data),
00074 globalData(global_data),
00075 printParams(printingParams),
00076 params(p),
00077 userInterface(i),
00078 userInterfaceTime(),
00079 userInterfaceTimeMF(),
00080 shiftedSharedLinearSystem(),
00081 isValidShiftedPrec(false),
00082 alpha_(1.0),
00083 beta_(0.0),
00084 tmpVectorPtr2(),
00085 scaleVecPtr(),
00086 tls_strategy(),
00087 complexSharedLinearSystem(),
00088 complexMatrix(),
00089 complexVec(),
00090 isValidComplex(false),
00091 isValidComplexPrec(false)
00092 {
00093 }
00094
00095 LOCA::Epetra::Group::Group(
00096 const Teuchos::RCP<LOCA::GlobalData>& global_data,
00097 Teuchos::ParameterList& printingParams,
00098 const Teuchos::RCP<LOCA::Epetra::Interface::Required>& i,
00099 NOX::Epetra::Vector& initialGuess,
00100 const Teuchos::RCP<NOX::Epetra::LinearSystem>& linSys,
00101 const LOCA::ParameterVector& p) :
00102 NOX::Epetra::Group(printingParams, i, initialGuess, linSys),
00103 LOCA::Abstract::Group(global_data),
00104 globalData(global_data),
00105 printParams(printingParams),
00106 params(p),
00107 userInterface(i),
00108 userInterfaceTime(),
00109 userInterfaceTimeMF(),
00110 shiftedSharedLinearSystem(),
00111 isValidShiftedPrec(false),
00112 alpha_(1.0),
00113 beta_(0.0),
00114 tmpVectorPtr2(),
00115 scaleVecPtr(),
00116 tls_strategy(),
00117 complexSharedLinearSystem(),
00118 complexMatrix(),
00119 complexVec(),
00120 isValidComplex(false),
00121 isValidComplexPrec(false)
00122 {
00123 }
00124
00125 LOCA::Epetra::Group::Group(
00126 const Teuchos::RCP<LOCA::GlobalData>& global_data,
00127 Teuchos::ParameterList& printingParams,
00128 const Teuchos::RCP<LOCA::Epetra::Interface::TimeDependent>& i,
00129 NOX::Epetra::Vector& initialGuess,
00130 const Teuchos::RCP<NOX::Epetra::LinearSystem>& linSys,
00131 const Teuchos::RCP<NOX::Epetra::LinearSystem>& shiftedLinSys,
00132 const LOCA::ParameterVector& p) :
00133 NOX::Epetra::Group(printingParams, i, initialGuess, linSys),
00134 LOCA::Abstract::Group(global_data),
00135 globalData(global_data),
00136 printParams(printingParams),
00137 params(p),
00138 userInterface(i),
00139 userInterfaceTime(i),
00140 userInterfaceTimeMF(),
00141 shiftedSharedLinearSystem(),
00142 isValidShiftedPrec(false),
00143 alpha_(1.0),
00144 beta_(0.0),
00145 tmpVectorPtr2(),
00146 scaleVecPtr(),
00147 tls_strategy(),
00148 complexSharedLinearSystem(),
00149 complexMatrix(),
00150 complexVec(),
00151 isValidComplex(false),
00152 isValidComplexPrec(false)
00153 {
00154 shiftedSharedLinearSystem =
00155 Teuchos::rcp(new NOX::SharedObject<NOX::Epetra::LinearSystem,
00156 LOCA::Epetra::Group>(shiftedLinSys));
00157 }
00158
00159 LOCA::Epetra::Group::Group(
00160 const Teuchos::RCP<LOCA::GlobalData>& global_data,
00161 Teuchos::ParameterList& printingParams,
00162 const Teuchos::RCP<LOCA::Epetra::Interface::TimeDependentMatrixFree>& i,
00163 NOX::Epetra::Vector& initialGuess,
00164 const Teuchos::RCP<NOX::Epetra::LinearSystem>& linSys,
00165 const Teuchos::RCP<NOX::Epetra::LinearSystem>& shiftedLinSys,
00166 const LOCA::ParameterVector& p) :
00167 NOX::Epetra::Group(printingParams, i, initialGuess, linSys),
00168 LOCA::Abstract::Group(global_data),
00169 globalData(global_data),
00170 printParams(printingParams),
00171 params(p),
00172 userInterface(i),
00173 userInterfaceTime(),
00174 userInterfaceTimeMF(i),
00175 shiftedSharedLinearSystem(),
00176 isValidShiftedPrec(false),
00177 alpha_(1.0),
00178 beta_(0.0),
00179 tmpVectorPtr2(),
00180 scaleVecPtr(),
00181 tls_strategy(),
00182 complexSharedLinearSystem(),
00183 complexMatrix(),
00184 complexVec(),
00185 isValidComplex(false),
00186 isValidComplexPrec(false)
00187 {
00188 shiftedSharedLinearSystem =
00189 Teuchos::rcp(new NOX::SharedObject<NOX::Epetra::LinearSystem,
00190 LOCA::Epetra::Group>(shiftedLinSys));
00191 }
00192
00193 LOCA::Epetra::Group::Group(const LOCA::Epetra::Group& source,
00194 NOX::CopyType type) :
00195 NOX::Epetra::Group(source, type),
00196 LOCA::Abstract::Group(source, type),
00197 globalData(source.globalData),
00198 printParams(source.printParams),
00199 params(source.params),
00200 userInterface(source.userInterface),
00201 userInterfaceTime(source.userInterfaceTime),
00202 userInterfaceTimeMF(source.userInterfaceTimeMF),
00203 shiftedSharedLinearSystem(source.shiftedSharedLinearSystem),
00204 isValidShiftedPrec(source.isValidShiftedPrec),
00205 alpha_(source.alpha_),
00206 beta_(source.beta_),
00207 tmpVectorPtr2(),
00208 scaleVecPtr(),
00209 tls_strategy(),
00210 complexSharedLinearSystem(source.complexSharedLinearSystem),
00211 complexMatrix(source.complexMatrix),
00212 complexVec(source.complexVec),
00213 isValidComplex(source.isValidComplex),
00214 isValidComplexPrec(source.isValidComplexPrec)
00215 {
00216 if (source.scaleVecPtr != Teuchos::null)
00217 scaleVecPtr = source.scaleVecPtr->clone(NOX::DeepCopy);
00218
00219
00220 if (shiftedSharedLinearSystem != Teuchos::null && type == NOX::DeepCopy)
00221 shiftedSharedLinearSystem->getObject(this);
00222
00223
00224 if (complexSharedLinearSystem != Teuchos::null && type == NOX::DeepCopy)
00225 complexSharedLinearSystem->getObject(this);
00226 }
00227
00228 LOCA::Epetra::Group::~Group()
00229 {
00230 }
00231
00232 LOCA::Epetra::Group&
00233 LOCA::Epetra::Group::operator=(const LOCA::Epetra::Group& source)
00234 {
00235 if (this != &source) {
00236 params = source.params;
00237 NOX::Epetra::Group::operator=(source);
00238 LOCA::Abstract::Group::copy(source);
00239 params = source.params;
00240 userInterface = source.userInterface;
00241 userInterfaceTime = source.userInterfaceTime;
00242 if (source.scaleVecPtr != Teuchos::null)
00243 scaleVecPtr = source.scaleVecPtr->clone(NOX::DeepCopy);
00244
00245
00246 if (shiftedSharedLinearSystem != Teuchos::null)
00247 shiftedSharedLinearSystem->getObject(this);
00248 isValidShiftedPrec = source.isValidShiftedPrec;
00249 alpha_ = source.alpha_;
00250 beta_ = source.beta_;
00251
00252
00253 if (complexSharedLinearSystem != Teuchos::null)
00254 complexSharedLinearSystem->getObject(this);
00255 isValidComplex = source.isValidComplex;
00256 isValidComplexPrec = source.isValidComplexPrec;
00257 }
00258 return *this;
00259 }
00260
00261 NOX::Abstract::Group&
00262 LOCA::Epetra::Group::operator=(const NOX::Abstract::Group& source)
00263 {
00264 operator=(dynamic_cast<const Group&> (source));
00265 return *this;
00266 }
00267
00268 NOX::Abstract::Group&
00269 LOCA::Epetra::Group::operator=(const NOX::Epetra::Group& source)
00270 {
00271 operator=(dynamic_cast<const Group&> (source));
00272 return *this;
00273 }
00274
00275 Teuchos::RCP<NOX::Abstract::Group>
00276 LOCA::Epetra::Group::clone(NOX::CopyType type) const
00277 {
00278 return Teuchos::rcp(new LOCA::Epetra::Group(*this, type));
00279 }
00280
00281 NOX::Abstract::Group::ReturnType
00282 LOCA::Epetra::Group::computeF()
00283 {
00284
00285 if (isF())
00286 return Abstract::Group::Ok;
00287
00288
00289 userInterface->setParameters(params);
00290
00291 return NOX::Epetra::Group::computeF();
00292 }
00293
00294 NOX::Abstract::Group::ReturnType
00295 LOCA::Epetra::Group::computeJacobian()
00296 {
00297
00298 if (isJacobian())
00299 return Abstract::Group::Ok;
00300
00301
00302 userInterface->setParameters(params);
00303
00304 return NOX::Epetra::Group::computeJacobian();
00305 }
00306
00307 NOX::Abstract::Group::ReturnType
00308 LOCA::Epetra::Group::applyJacobianTransposeInverse(
00309 Teuchos::ParameterList& params,
00310 const NOX::Abstract::Vector& input,
00311 NOX::Abstract::Vector& result) const
00312 {
00313 string callingFunction =
00314 "LOCA::Epetra::Group::applyJacobianTransposeInverse()";
00315 NOX::Abstract::Group::ReturnType status;
00316
00317
00318 Teuchos::RCP<NOX::Epetra::LinearSystem> linSys =
00319 sharedLinearSystem.getObject(this);
00320
00321
00322 Teuchos::RCP<Epetra_Operator> jac =
00323 linSys->getJacobianOperator();
00324
00325
00326 LOCA::Epetra::TransposeLinearSystem::Factory tls_factory(globalData);
00327 if (tls_strategy == Teuchos::null)
00328 tls_strategy = tls_factory.create(Teuchos::rcp(¶ms, false), linSys);
00329
00330
00331 tls_strategy->createJacobianTranspose();
00332
00333
00334 tls_strategy->createTransposePreconditioner(xVector, params);
00335
00336
00337 bool stat =
00338 tls_strategy->applyJacobianTransposeInverse(
00339 params,
00340 dynamic_cast<const NOX::Epetra::Vector&>(input),
00341 dynamic_cast<NOX::Epetra::Vector&>(result));
00342 if (stat == true)
00343 status = NOX::Abstract::Group::Ok;
00344 else
00345 status = NOX::Abstract::Group::NotConverged;
00346
00347
00348 jac->SetUseTranspose(false);
00349 linSys->setJacobianOperatorForSolve(jac);
00350 linSys->destroyPreconditioner();
00351
00352 return status;
00353 }
00354
00355 NOX::Abstract::Group::ReturnType
00356 LOCA::Epetra::Group::applyJacobianTransposeInverseMultiVector(
00357 Teuchos::ParameterList& params,
00358 const NOX::Abstract::MultiVector& input,
00359 NOX::Abstract::MultiVector& result) const
00360 {
00361 string callingFunction =
00362 "LOCA::Epetra::Group::applyJacobianTransposeInverseMultiVector()";
00363 NOX::Abstract::Group::ReturnType status;
00364 NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
00365
00366
00367 Teuchos::RCP<NOX::Epetra::LinearSystem> linSys =
00368 sharedLinearSystem.getObject(this);
00369
00370
00371 Teuchos::RCP<Epetra_Operator> jac =
00372 linSys->getJacobianOperator();
00373
00374
00375 LOCA::Epetra::TransposeLinearSystem::Factory tls_factory(globalData);
00376 if (tls_strategy == Teuchos::null)
00377 tls_strategy = tls_factory.create(Teuchos::rcp(¶ms, false), linSys);
00378
00379
00380 tls_strategy->createJacobianTranspose();
00381
00382
00383 tls_strategy->createTransposePreconditioner(xVector, params);
00384
00385
00386 int m = input.numVectors();
00387 for (int i=0; i<m; i++) {
00388 bool stat =
00389 tls_strategy->applyJacobianTransposeInverse(
00390 params,
00391 dynamic_cast<const NOX::Epetra::Vector&>(input[i]),
00392 dynamic_cast<NOX::Epetra::Vector&>(result[i]));
00393 if (stat == true)
00394 status = NOX::Abstract::Group::Ok;
00395 else
00396 status = NOX::Abstract::Group::NotConverged;
00397 finalStatus =
00398 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
00399 finalStatus,
00400 callingFunction);
00401 }
00402
00403
00404 jac->SetUseTranspose(false);
00405 linSys->setJacobianOperatorForSolve(jac);
00406 linSys->destroyPreconditioner();
00407
00408 return finalStatus;
00409 }
00410
00411 void
00412 LOCA::Epetra::Group::copy(const NOX::Abstract::Group& source)
00413 {
00414 *this = source;
00415 }
00416
00417 void
00418 LOCA::Epetra::Group::setParams(const LOCA::ParameterVector& p)
00419 {
00420 resetIsValid();
00421 params = p;
00422 }
00423
00424 void
00425 LOCA::Epetra::Group::setParam(int paramID, double val)
00426 {
00427 resetIsValid();
00428 params.setValue(paramID, val);
00429 }
00430
00431 void
00432 LOCA::Epetra::Group::setParam(string paramID, double val)
00433 {
00434 resetIsValid();
00435 params.setValue(paramID, val);
00436 }
00437
00438 const LOCA::ParameterVector&
00439 LOCA::Epetra::Group::getParams() const
00440 {
00441 return params;
00442 }
00443
00444 double
00445 LOCA::Epetra::Group::getParam(int paramID) const
00446 {
00447 return params.getValue(paramID);
00448 }
00449
00450 double
00451 LOCA::Epetra::Group::getParam(string paramID) const
00452 {
00453 return params.getValue(paramID);
00454 }
00455
00456 void
00457 LOCA::Epetra::Group:: preProcessContinuationStep(
00458 LOCA::Abstract::Iterator::StepStatus stepStatus)
00459 {
00460 userInterface->preProcessContinuationStep(stepStatus, *this);
00461 }
00462
00463 void
00464 LOCA::Epetra::Group:: postProcessContinuationStep(
00465 LOCA::Abstract::Iterator::StepStatus stepStatus)
00466 {
00467 userInterface->postProcessContinuationStep(stepStatus, *this);
00468 }
00469
00470 void
00471 LOCA::Epetra::Group::projectToDraw(const NOX::Abstract::Vector& x,
00472 double *px) const
00473 {
00474 const NOX::Epetra::Vector& ex =
00475 dynamic_cast<const NOX::Epetra::Vector&>(x);
00476 userInterface->projectToDraw(ex, px);
00477 }
00478
00479 int
00480 LOCA::Epetra::Group::projectToDrawDimension() const
00481 {
00482 return userInterface->projectToDrawDimension();
00483 }
00484
00485 double
00486 LOCA::Epetra::Group::computeScaledDotProduct(
00487 const NOX::Abstract::Vector& a,
00488 const NOX::Abstract::Vector& b) const
00489 {
00490 if (scaleVecPtr == Teuchos::null)
00491 return a.innerProduct(b) / a.length();
00492 else {
00493 Teuchos::RCP<NOX::Abstract::Vector> as = a.clone(NOX::DeepCopy);
00494 Teuchos::RCP<NOX::Abstract::Vector> bs = b.clone(NOX::DeepCopy);
00495 double d;
00496
00497 as->scale(*scaleVecPtr);
00498 bs->scale(*scaleVecPtr);
00499 d = as->innerProduct(*bs);
00500
00501 return d;
00502 }
00503 }
00504
00505 void
00506 LOCA::Epetra::Group::printSolution(const double conParam) const
00507 {
00508 printSolution(xVector, conParam);
00509 }
00510
00511 void
00512 LOCA::Epetra::Group::printSolution(const NOX::Abstract::Vector& x_,
00513 const double conParam) const
00514 {
00515 printSolution(dynamic_cast<const NOX::Epetra::Vector&>(x_), conParam);
00516 }
00517
00518 void
00519 LOCA::Epetra::Group::scaleVector(NOX::Abstract::Vector& x) const
00520 {
00521 if (scaleVecPtr == Teuchos::null)
00522 x.scale(1.0 / sqrt(static_cast<double>(x.length())));
00523 else
00524 x.scale(*scaleVecPtr);
00525 }
00526
00527 NOX::Abstract::Group::ReturnType
00528 LOCA::Epetra::Group::augmentJacobianForHomotopy(double a, double b)
00529 {
00530
00531
00532 if (tmpVectorPtr == Teuchos::null)
00533 tmpVectorPtr = Teuchos::rcp(new Epetra_Vector(xVector.getEpetraVector()));
00534 if (tmpVectorPtr2 == Teuchos::null)
00535 tmpVectorPtr2 = Teuchos::rcp(new Epetra_Vector(xVector.getEpetraVector()));
00536
00537 tmpVectorPtr2->PutScalar(b);
00538
00539
00540 Teuchos::RCP<const Epetra_CrsMatrix> constTestCrs;
00541 Teuchos::RCP<Epetra_CrsMatrix> testCrs;
00542 constTestCrs = Teuchos::rcp_dynamic_cast<const Epetra_CrsMatrix>
00543 (sharedLinearSystem.getObject(this)->getJacobianOperator());
00544 if (constTestCrs != Teuchos::null) {
00545 testCrs = Teuchos::rcp_const_cast<Epetra_CrsMatrix>(constTestCrs);
00546 testCrs->Scale(a);
00547 testCrs->ExtractDiagonalCopy(*tmpVectorPtr);
00548 tmpVectorPtr->Update(1.0, *tmpVectorPtr2, 1.0);
00549 testCrs->ReplaceDiagonalValues(*tmpVectorPtr);
00550 return LOCA::Abstract::Group::Ok;
00551
00552 }
00553
00554
00555 Teuchos::RCP<const Epetra_VbrMatrix> constTestVbr;
00556 Teuchos::RCP<Epetra_VbrMatrix> testVbr;
00557 constTestVbr = Teuchos::rcp_dynamic_cast<const Epetra_VbrMatrix>
00558 (sharedLinearSystem.getObject(this)->getJacobianOperator());
00559 if (constTestVbr != Teuchos::null) {
00560 testVbr = Teuchos::rcp_const_cast<Epetra_VbrMatrix>(constTestVbr);
00561 testVbr->Scale(a);
00562 testVbr->ExtractDiagonalCopy(*tmpVectorPtr);
00563 tmpVectorPtr->Update(1.0, *tmpVectorPtr2, 1.0);
00564 testVbr->ReplaceDiagonalValues(*tmpVectorPtr);
00565 return LOCA::Abstract::Group::Ok;
00566 }
00567
00568
00569
00570 return LOCA::Abstract::Group::NotDefined;
00571 }
00572
00573 NOX::Abstract::Group::ReturnType
00574 LOCA::Epetra::Group::computeShiftedMatrix(double alpha, double beta)
00575 {
00576
00577 if (userInterfaceTime != Teuchos::null) {
00578 Teuchos::RCP<Epetra_Operator> mass =
00579 shiftedSharedLinearSystem->getObject(this)->getJacobianOperator();
00580
00581 bool res =
00582 userInterfaceTime->computeShiftedMatrix(alpha, beta,
00583 xVector.getEpetraVector(),
00584 *mass);
00585
00586
00587
00588 Teuchos::RCP<Epetra_Operator> jac =
00589 sharedLinearSystem.getObject(this)->getJacobianOperator();
00590 if (mass.get() == jac.get())
00591 isValidJacobian = false;
00592
00593 if (res)
00594 return NOX::Abstract::Group::Ok;
00595 else
00596 return NOX::Abstract::Group::Failed;
00597 }
00598
00599
00600 else if (userInterfaceTimeMF != Teuchos::null) {
00601 alpha_ = alpha;
00602 beta_ = beta;
00603 return NOX::Abstract::Group::Ok;
00604 }
00605
00606
00607 else
00608 return NOX::Abstract::Group::BadDependency;
00609 }
00610
00611 NOX::Abstract::Group::ReturnType
00612 LOCA::Epetra::Group::applyShiftedMatrix(const NOX::Abstract::Vector& input,
00613 NOX::Abstract::Vector& result) const
00614 {
00615 const NOX::Epetra::Vector& epetra_input =
00616 dynamic_cast<const NOX::Epetra::Vector&>(input);
00617 NOX::Epetra::Vector& epetra_result =
00618 dynamic_cast<NOX::Epetra::Vector&>(result);
00619
00620
00621 if (userInterfaceTime != Teuchos::null) {
00622 bool res =
00623 shiftedSharedLinearSystem->getObject()->applyJacobian(epetra_input,
00624 epetra_result);
00625 if (res)
00626 return NOX::Abstract::Group::Ok;
00627 else
00628 return NOX::Abstract::Group::Failed;
00629 }
00630
00631
00632 else if (userInterfaceTimeMF != Teuchos::null) {
00633 bool res = userInterfaceTimeMF->applyShiftedMatrix(alpha_, beta_,
00634 epetra_input,
00635 epetra_result);
00636 if (res)
00637 return NOX::Abstract::Group::Ok;
00638 else
00639 return NOX::Abstract::Group::Failed;
00640 }
00641
00642
00643 else
00644 return NOX::Abstract::Group::BadDependency;
00645 }
00646
00647 NOX::Abstract::Group::ReturnType
00648 LOCA::Epetra::Group::applyShiftedMatrixMultiVector(
00649 const NOX::Abstract::MultiVector& input,
00650 NOX::Abstract::MultiVector& result) const
00651 {
00652 string callingFunction =
00653 "LOCA::Epetra::Group::applyShiftedMatrixMultiVector()";
00654 NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
00655 NOX::Abstract::Group::ReturnType status;
00656
00657 for (int i=0; i<input.numVectors(); i++) {
00658 status = applyShiftedMatrix(input[i], result[i]);
00659 finalStatus =
00660 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
00661 finalStatus,
00662 callingFunction);
00663 }
00664
00665 return finalStatus;
00666 }
00667
00668 NOX::Abstract::Group::ReturnType
00669 LOCA::Epetra::Group::applyShiftedMatrixInverseMultiVector(
00670 Teuchos::ParameterList& lsParams,
00671 const NOX::Abstract::MultiVector& input,
00672 NOX::Abstract::MultiVector& result) const
00673 {
00674
00675 if (shiftedSharedLinearSystem != Teuchos::null) {
00676
00677 NOX::Epetra::LinearSystem::PreconditionerReusePolicyType precPolicy =
00678 sharedLinearSystem.getObject(this)->getPreconditionerPolicy();
00679
00680 if (!isValidShiftedPrec) {
00681
00682 if (precPolicy == NOX::Epetra::LinearSystem::PRPT_REBUILD) {
00683 shiftedSharedLinearSystem->getObject(this)->destroyPreconditioner();
00684 shiftedSharedLinearSystem->getObject(this)->
00685 createPreconditioner(xVector, lsParams, false);
00686 isValidShiftedPrec = true;
00687 }
00688 else if (precPolicy == NOX::Epetra::LinearSystem::PRPT_RECOMPUTE) {
00689 sharedLinearSystem.getObject(this)->recomputePreconditioner(xVector,
00690 lsParams);
00691 }
00692 else if (precPolicy == NOX::Epetra::LinearSystem::PRPT_REUSE) {
00693
00694 }
00695
00696 }
00697
00698
00699
00700 const NOX::Epetra::Vector* epetra_input;
00701 NOX::Epetra::Vector* epetra_result;
00702 bool status;
00703 bool finalStatus = true;
00704 for (int i=0; i<input.numVectors(); i++) {
00705 epetra_input = dynamic_cast<const NOX::Epetra::Vector*>(&input[i]);
00706 epetra_result = dynamic_cast<NOX::Epetra::Vector*>(&result[i]);
00707
00708 status =
00709 shiftedSharedLinearSystem->getObject(this)->applyJacobianInverse(
00710 lsParams,
00711 *epetra_input,
00712 *epetra_result);
00713 finalStatus = finalStatus && status;
00714 }
00715
00716 if (finalStatus)
00717 return NOX::Abstract::Group::Ok;
00718 else
00719 return NOX::Abstract::Group::NotConverged;
00720 }
00721
00722 else
00723 return NOX::Abstract::Group::BadDependency;
00724 }
00725
00726 bool
00727 LOCA::Epetra::Group::isComplex() const
00728 {
00729 return isValidComplex;
00730 }
00731
00732 NOX::Abstract::Group::ReturnType
00733 LOCA::Epetra::Group::computeComplex(double frequency)
00734 {
00735 string callingFunction =
00736 "LOCA::Epetra::Group::computeComplex()";
00737
00738
00739 if (userInterfaceTime == Teuchos::null)
00740 return NOX::Abstract::Group::BadDependency;
00741
00742 #ifdef HAVE_NOX_EPETRAEXT
00743 if (isValidComplex)
00744 return NOX::Abstract::Group::Ok;
00745
00746 NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
00747 NOX::Abstract::Group::ReturnType status;
00748
00749
00750 Teuchos::RCP<Epetra_RowMatrix> jac = Teuchos::rcp_dynamic_cast<Epetra_RowMatrix>(sharedLinearSystem.getObject(this)->getJacobianOperator());
00751
00752
00753 if (complexMatrix == Teuchos::null) {
00754 std::vector< std::vector<int> >rowStencil(2);
00755 std::vector<int> rowIndex;
00756
00757 rowStencil[0].push_back(0); rowStencil[0].push_back(1);
00758 rowStencil[1].push_back(-1); rowStencil[1].push_back(0);
00759 rowIndex.push_back(0); rowIndex.push_back(1);
00760
00761 complexMatrix = Teuchos::rcp(new EpetraExt::BlockCrsMatrix(*jac,
00762 rowStencil,
00763 rowIndex,
00764 jac->Comm()));
00765
00766
00767 complexVec =
00768 Teuchos::rcp(new EpetraExt::BlockVector(jac->RowMatrixRowMap(),
00769 complexMatrix->RowMap()));
00770 }
00771
00772
00773 Teuchos::RCP<Epetra_RowMatrix> mass = Teuchos::rcp_dynamic_cast<Epetra_RowMatrix>(shiftedSharedLinearSystem->getObject(this)->getJacobianOperator());
00774
00775
00776 status = computeShiftedMatrix(0.0, frequency);
00777 finalStatus =
00778 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
00779 finalStatus,
00780 callingFunction);
00781
00782
00783 complexMatrix->LoadBlock(*mass, 1, 0);
00784
00785
00786 status = computeShiftedMatrix(0.0, -frequency);
00787 finalStatus =
00788 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
00789 finalStatus,
00790 callingFunction);
00791
00792
00793 complexMatrix->LoadBlock(*mass, 0, 1);
00794
00795
00796 status = computeJacobian();
00797 finalStatus =
00798 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
00799 finalStatus,
00800 callingFunction);
00801
00802
00803 complexMatrix->LoadBlock(*jac, 0, 0);
00804 complexMatrix->LoadBlock(*jac, 1, 1);
00805
00806
00807 if (complexSharedLinearSystem == Teuchos::null) {
00808
00809 NOX::Epetra::Vector nev(complexVec, NOX::Epetra::Vector::CreateView);
00810
00811 Teuchos::RCP<Teuchos::ParameterList> lsParams =
00812 globalData->parsedParams->getSublist("Linear Solver");
00813
00814
00815 Teuchos::RCP<NOX::Epetra::Interface::Required> iReq;
00816 Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac;
00817 Teuchos::RCP<NOX::Epetra::LinearSystem> complexLinSys =
00818 Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams,
00819 *lsParams,
00820 iReq,
00821 iJac,
00822 complexMatrix,
00823 nev));
00824 complexLinSys->setJacobianOperatorForSolve(complexMatrix);
00825 complexSharedLinearSystem =
00826 Teuchos::rcp(new NOX::SharedObject<NOX::Epetra::LinearSystem,
00827 LOCA::Epetra::Group>(complexLinSys));
00828 }
00829
00830 if (finalStatus == NOX::Abstract::Group::Ok)
00831 isValidComplex = true;
00832
00833 return finalStatus;
00834
00835 #else
00836
00837 globalData->locaErrorCheck->throwError(callingFunction,
00838 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
00839 return NOX::Abstract::Group::BadDependency;
00840
00841 #endif
00842 }
00843
00844 NOX::Abstract::Group::ReturnType
00845 LOCA::Epetra::Group::applyComplex(const NOX::Abstract::Vector& input_real,
00846 const NOX::Abstract::Vector& input_imag,
00847 NOX::Abstract::Vector& result_real,
00848 NOX::Abstract::Vector& result_imag) const
00849 {
00850 string callingFunction =
00851 "LOCA::Epetra::Group::applyComplex()";
00852
00853
00854 if (userInterfaceTime == Teuchos::null)
00855 return NOX::Abstract::Group::BadDependency;
00856
00857 #ifdef HAVE_NOX_EPETRAEXT
00858 const NOX::Epetra::Vector& epetra_input_real =
00859 dynamic_cast<const NOX::Epetra::Vector&>(input_real);
00860 const NOX::Epetra::Vector& epetra_input_imag =
00861 dynamic_cast<const NOX::Epetra::Vector&>(input_imag);
00862 NOX::Epetra::Vector& epetra_result_real =
00863 dynamic_cast<NOX::Epetra::Vector&>(result_real);
00864 NOX::Epetra::Vector& epetra_result_imag =
00865 dynamic_cast<NOX::Epetra::Vector&>(result_imag);
00866
00867 EpetraExt::BlockVector complex_input(*complexVec);
00868 complex_input.LoadBlockValues(epetra_input_real.getEpetraVector(), 0);
00869 complex_input.LoadBlockValues(epetra_input_imag.getEpetraVector(), 1);
00870
00871 EpetraExt::BlockVector complex_result(*complexVec);
00872 complex_result.PutScalar(0.0);
00873
00874 complexMatrix->Apply(complex_input, complex_result);
00875
00876 complex_result.ExtractBlockValues(epetra_result_real.getEpetraVector(), 0);
00877 complex_result.ExtractBlockValues(epetra_result_imag.getEpetraVector(), 1);
00878
00879 return NOX::Abstract::Group::Ok;
00880 #else
00881
00882 globalData->locaErrorCheck->throwError(callingFunction,
00883 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
00884 return NOX::Abstract::Group::BadDependency;
00885
00886 #endif
00887 }
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913 NOX::Abstract::Group::ReturnType
00914 LOCA::Epetra::Group::applyComplexMultiVector(
00915 const NOX::Abstract::MultiVector& input_real,
00916 const NOX::Abstract::MultiVector& input_imag,
00917 NOX::Abstract::MultiVector& result_real,
00918 NOX::Abstract::MultiVector& result_imag) const
00919 {
00920 string callingFunction =
00921 "LOCA::Epetra::Group::applyComplexMultiVector()";
00922
00923 if (userInterfaceTime == Teuchos::null)
00924 return NOX::Abstract::Group::BadDependency;
00925
00926 #ifdef HAVE_NOX_EPETRAEXT
00927 const NOX::Epetra::MultiVector& epetra_input_real =
00928 dynamic_cast<const NOX::Epetra::MultiVector&>(input_real);
00929 const NOX::Epetra::MultiVector& epetra_input_imag =
00930 dynamic_cast<const NOX::Epetra::MultiVector&>(input_imag);
00931 NOX::Epetra::MultiVector& epetra_result_real =
00932 dynamic_cast<NOX::Epetra::MultiVector&>(result_real);
00933 NOX::Epetra::MultiVector& epetra_result_imag =
00934 dynamic_cast<NOX::Epetra::MultiVector&>(result_imag);
00935
00936
00937 Teuchos::RCP<Epetra_RowMatrix> jac = Teuchos::rcp_dynamic_cast<Epetra_RowMatrix>(sharedLinearSystem.getObject(this)->getJacobianOperator());
00938
00939 EpetraExt::BlockMultiVector complex_input(jac->RowMatrixRowMap(),
00940 complexMatrix->RowMap(),
00941 input_real.numVectors());
00942 complex_input.LoadBlockValues(epetra_input_real.getEpetraMultiVector(), 0);
00943 complex_input.LoadBlockValues(epetra_input_imag.getEpetraMultiVector(), 1);
00944
00945 EpetraExt::BlockMultiVector complex_result(jac->RowMatrixRowMap(),
00946 complexMatrix->RowMap(),
00947 input_real.numVectors());
00948 complex_result.PutScalar(0.0);
00949
00950 complexMatrix->Apply(complex_input, complex_result);
00951
00952 complex_result.ExtractBlockValues(epetra_result_real.getEpetraMultiVector(),
00953 0);
00954 complex_result.ExtractBlockValues(epetra_result_imag.getEpetraMultiVector(),
00955 1);
00956
00957 return NOX::Abstract::Group::Ok;
00958 #else
00959
00960 globalData->locaErrorCheck->throwError(callingFunction,
00961 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
00962 return NOX::Abstract::Group::BadDependency;
00963
00964 #endif
00965 }
00966
00967 NOX::Abstract::Group::ReturnType
00968 LOCA::Epetra::Group::applyComplexInverseMultiVector(
00969 Teuchos::ParameterList& lsParams,
00970 const NOX::Abstract::MultiVector& input_real,
00971 const NOX::Abstract::MultiVector& input_imag,
00972 NOX::Abstract::MultiVector& result_real,
00973 NOX::Abstract::MultiVector& result_imag) const
00974 {
00975 string callingFunction =
00976 "LOCA::Epetra::Group::applyComplexInverseMultiVector()";
00977
00978
00979 if (userInterfaceTime == Teuchos::null)
00980 return NOX::Abstract::Group::BadDependency;
00981
00982 #ifdef HAVE_NOX_EPETRAEXT
00983
00984
00985 NOX::Epetra::LinearSystem::PreconditionerReusePolicyType precPolicy =
00986 complexSharedLinearSystem->getObject(this)->getPreconditionerPolicy();
00987
00988 if (!isValidComplexPrec) {
00989 if (precPolicy == NOX::Epetra::LinearSystem::PRPT_REBUILD) {
00990 complexSharedLinearSystem->getObject(this)->destroyPreconditioner();
00991 complexSharedLinearSystem->getObject(this)->
00992 createPreconditioner(xVector,
00993 lsParams,
00994 false);
00995 isValidComplexPrec = true;
00996 }
00997 else if (precPolicy == NOX::Epetra::LinearSystem::PRPT_RECOMPUTE) {
00998 complexSharedLinearSystem->getObject(this)->
00999 recomputePreconditioner(xVector, lsParams);
01000 }
01001 else if (precPolicy == NOX::Epetra::LinearSystem::PRPT_REUSE) {
01002
01003 }
01004 }
01005
01006 EpetraExt::BlockVector complex_input(*complexVec);
01007 EpetraExt::BlockVector complex_result(*complexVec);
01008 NOX::Epetra::Vector nev_input(Teuchos::rcp(&complex_input,false),
01009 NOX::Epetra::Vector::CreateView);
01010 NOX::Epetra::Vector nev_result(Teuchos::rcp(&complex_result,false),
01011 NOX::Epetra::Vector::CreateView);
01012 const NOX::Epetra::Vector* epetra_input_real;
01013 const NOX::Epetra::Vector* epetra_input_imag;
01014 NOX::Epetra::Vector* epetra_result_real;
01015 NOX::Epetra::Vector* epetra_result_imag;
01016 bool status;
01017 bool finalStatus = true;
01018 for (int i=0; i<input_real.numVectors(); i++) {
01019 epetra_input_real =
01020 dynamic_cast<const NOX::Epetra::Vector*>(&input_real[i]);
01021 epetra_input_imag =
01022 dynamic_cast<const NOX::Epetra::Vector*>(&input_imag[i]);
01023 epetra_result_real = dynamic_cast<NOX::Epetra::Vector*>(&result_real[i]);
01024 epetra_result_imag = dynamic_cast<NOX::Epetra::Vector*>(&result_imag[i]);
01025
01026 complex_input.LoadBlockValues(epetra_input_real->getEpetraVector(), 0);
01027 complex_input.LoadBlockValues(epetra_input_imag->getEpetraVector(), 1);
01028 complex_result.PutScalar(0.0);
01029
01030 status =
01031 complexSharedLinearSystem->getObject(this)->applyJacobianInverse(
01032 lsParams,
01033 nev_input,
01034 nev_result);
01035
01036 complex_result.ExtractBlockValues(epetra_result_real->getEpetraVector(),0);
01037 complex_result.ExtractBlockValues(epetra_result_imag->getEpetraVector(),1);
01038
01039 finalStatus = finalStatus && status;
01040 }
01041
01042 if (finalStatus)
01043 return NOX::Abstract::Group::Ok;
01044 else
01045 return NOX::Abstract::Group::NotConverged;
01046 #else
01047
01048 globalData->locaErrorCheck->throwError(callingFunction,
01049 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
01050 return NOX::Abstract::Group::BadDependency;
01051
01052 #endif
01053 }
01054
01055 NOX::Abstract::Group::ReturnType
01056 LOCA::Epetra::Group::applyComplexTranspose(
01057 const NOX::Abstract::Vector& input_real,
01058 const NOX::Abstract::Vector& input_imag,
01059 NOX::Abstract::Vector& result_real,
01060 NOX::Abstract::Vector& result_imag) const
01061 {
01062 string callingFunction =
01063 "LOCA::Epetra::Group::applyComplexTranspose()";
01064
01065
01066 if (userInterfaceTime == Teuchos::null)
01067 return NOX::Abstract::Group::BadDependency;
01068
01069 #ifdef HAVE_NOX_EPETRAEXT
01070 const NOX::Epetra::Vector& epetra_input_real =
01071 dynamic_cast<const NOX::Epetra::Vector&>(input_real);
01072 const NOX::Epetra::Vector& epetra_input_imag =
01073 dynamic_cast<const NOX::Epetra::Vector&>(input_imag);
01074 NOX::Epetra::Vector& epetra_result_real =
01075 dynamic_cast<NOX::Epetra::Vector&>(result_real);
01076 NOX::Epetra::Vector& epetra_result_imag =
01077 dynamic_cast<NOX::Epetra::Vector&>(result_imag);
01078
01079 EpetraExt::BlockVector complex_input(*complexVec);
01080 complex_input.LoadBlockValues(epetra_input_real.getEpetraVector(), 0);
01081 complex_input.LoadBlockValues(epetra_input_imag.getEpetraVector(), 1);
01082
01083 EpetraExt::BlockVector complex_result(*complexVec);
01084 complex_result.PutScalar(0.0);
01085
01086
01087
01088
01089 complexMatrix->SetUseTranspose(true);
01090 complexMatrix->Apply(complex_input, complex_result);
01091 complexMatrix->SetUseTranspose(false);
01092
01093 complex_result.ExtractBlockValues(epetra_result_real.getEpetraVector(), 0);
01094 complex_result.ExtractBlockValues(epetra_result_imag.getEpetraVector(), 1);
01095
01096 return NOX::Abstract::Group::Ok;
01097 #else
01098
01099 globalData->locaErrorCheck->throwError(callingFunction,
01100 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
01101 return NOX::Abstract::Group::BadDependency;
01102
01103 #endif
01104 }
01105
01106 NOX::Abstract::Group::ReturnType
01107 LOCA::Epetra::Group::applyComplexTransposeMultiVector(
01108 const NOX::Abstract::MultiVector& input_real,
01109 const NOX::Abstract::MultiVector& input_imag,
01110 NOX::Abstract::MultiVector& result_real,
01111 NOX::Abstract::MultiVector& result_imag) const
01112 {
01113 string callingFunction =
01114 "LOCA::Epetra::Group::applyComplexTransposeMultiVector()";
01115 NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
01116 NOX::Abstract::Group::ReturnType status;
01117
01118 for (int i=0; i<input_real.numVectors(); i++) {
01119 status = applyComplexTranspose(input_real[i], input_imag[i],
01120 result_real[i], result_imag[i]);
01121 finalStatus =
01122 globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
01123 finalStatus,
01124 callingFunction);
01125 }
01126
01127 return finalStatus;
01128 }
01129
01130 NOX::Abstract::Group::ReturnType
01131 LOCA::Epetra::Group::applyComplexTransposeInverseMultiVector(
01132 Teuchos::ParameterList& lsParams,
01133 const NOX::Abstract::MultiVector& input_real,
01134 const NOX::Abstract::MultiVector& input_imag,
01135 NOX::Abstract::MultiVector& result_real,
01136 NOX::Abstract::MultiVector& result_imag) const
01137 {
01138 string callingFunction =
01139 "LOCA::Epetra::Group::applyComplexTransposeInverseMultiVector()";
01140
01141
01142 if (userInterfaceTime == Teuchos::null)
01143 return NOX::Abstract::Group::BadDependency;
01144
01145 #ifdef HAVE_NOX_EPETRAEXT
01146 if (complexSharedLinearSystem == Teuchos::null) {
01147
01148 NOX::Epetra::Vector nev(complexVec, NOX::Epetra::Vector::CreateView);
01149
01150
01151 Teuchos::RCP<NOX::Epetra::Interface::Required> iReq;
01152 Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac;
01153 Teuchos::RCP<NOX::Epetra::LinearSystem> complexLinSys =
01154 Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams,
01155 lsParams,
01156 iReq,
01157 iJac,
01158 complexMatrix,
01159 nev));
01160 complexLinSys->setJacobianOperatorForSolve(complexMatrix);
01161 complexSharedLinearSystem =
01162 Teuchos::rcp(new NOX::SharedObject<NOX::Epetra::LinearSystem,
01163 LOCA::Epetra::Group>(complexLinSys));
01164 }
01165 Teuchos::RCP<NOX::Epetra::LinearSystem> complexLinSys =
01166 Teuchos::rcp_const_cast<NOX::Epetra::LinearSystem>(complexSharedLinearSystem->getObject());
01167
01168
01169 LOCA::Epetra::TransposeLinearSystem::Factory tls_factory(globalData);
01170 if (tls_strategy == Teuchos::null)
01171 tls_strategy = tls_factory.create(Teuchos::rcp(&lsParams, false),
01172 complexLinSys);
01173
01174
01175 tls_strategy->createJacobianTranspose();
01176
01177
01178 tls_strategy->createTransposePreconditioner(xVector, lsParams);
01179
01180
01181 EpetraExt::BlockVector complex_input(*complexVec);
01182 EpetraExt::BlockVector complex_result(*complexVec);
01183 NOX::Epetra::Vector nev_input(Teuchos::rcp(&complex_input,false),
01184 NOX::Epetra::Vector::CreateView);
01185 NOX::Epetra::Vector nev_result(Teuchos::rcp(&complex_result,false),
01186 NOX::Epetra::Vector::CreateView);
01187 const NOX::Epetra::Vector* epetra_input_real;
01188 const NOX::Epetra::Vector* epetra_input_imag;
01189 NOX::Epetra::Vector* epetra_result_real;
01190 NOX::Epetra::Vector* epetra_result_imag;
01191 bool status;
01192 bool finalStatus = true;
01193 for (int i=0; i<input_real.numVectors(); i++) {
01194 epetra_input_real =
01195 dynamic_cast<const NOX::Epetra::Vector*>(&input_real[i]);
01196 epetra_input_imag =
01197 dynamic_cast<const NOX::Epetra::Vector*>(&input_imag[i]);
01198 epetra_result_real = dynamic_cast<NOX::Epetra::Vector*>(&result_real[i]);
01199 epetra_result_imag = dynamic_cast<NOX::Epetra::Vector*>(&result_imag[i]);
01200
01201 complex_input.LoadBlockValues(epetra_input_real->getEpetraVector(), 0);
01202 complex_input.LoadBlockValues(epetra_input_imag->getEpetraVector(), 1);
01203 complex_result.PutScalar(0.0);
01204
01205 status =
01206 tls_strategy->applyJacobianTransposeInverse(lsParams,
01207 nev_input,
01208 nev_result);
01209
01210 complex_result.ExtractBlockValues(epetra_result_real->getEpetraVector(),0);
01211 complex_result.ExtractBlockValues(epetra_result_imag->getEpetraVector(),1);
01212
01213 finalStatus = finalStatus && status;
01214 }
01215
01216
01217 complexMatrix->SetUseTranspose(false);
01218 complexLinSys->setJacobianOperatorForSolve(complexMatrix);
01219 complexLinSys->destroyPreconditioner();
01220
01221 if (finalStatus)
01222 return NOX::Abstract::Group::Ok;
01223 else
01224 return NOX::Abstract::Group::NotConverged;
01225 #else
01226
01227 globalData->locaErrorCheck->throwError(callingFunction,
01228 "Must have EpetraExt support for Hopf tracking. Configure trilinos with --enable-epetraext");
01229 return NOX::Abstract::Group::BadDependency;
01230
01231 #endif
01232 }
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288 Teuchos::RCP<NOX::Epetra::Interface::Required>
01289 LOCA::Epetra::Group::getUserInterface()
01290 {
01291 return userInterface;
01292 }
01293
01294 void
01295 LOCA::Epetra::Group::printSolution(const NOX::Epetra::Vector& x_,
01296 const double conParam) const
01297 {
01298 userInterface->printSolution(x_.getEpetraVector(), conParam);
01299 }
01300
01301 void
01302 LOCA::Epetra::Group::setScaleVector(const NOX::Abstract::Vector& s)
01303 {
01304 scaleVecPtr = s.clone(NOX::DeepCopy);
01305
01306 return;
01307 }
01308
01309 void
01310 LOCA::Epetra::Group::setJacobianOperatorForSolve(
01311 const Teuchos::RCP<const Epetra_Operator>& op) const
01312 {
01313
01314 sharedLinearSystem.getObject(this)->setJacobianOperatorForSolve(op);
01315 isValidSolverJacOp = true;
01316 }
01317
01318 void
01319 LOCA::Epetra::Group::resetIsValid()
01320 {
01321 NOX::Epetra::Group::resetIsValid();
01322 isValidShiftedPrec = false;
01323 isValidComplex = false;
01324 isValidComplexPrec = false;
01325 }
01326
01327 Teuchos::RCP<const NOX::Epetra::LinearSystem>
01328 LOCA::Epetra::Group::getComplexLinearSystem() const
01329 {
01330 return complexSharedLinearSystem->getObject();
01331 }
01332
01333 Teuchos::RCP<NOX::Epetra::LinearSystem>
01334 LOCA::Epetra::Group::getComplexLinearSystem()
01335 {
01336 return complexSharedLinearSystem->getObject(this);
01337 }
01338
01339 void
01340 LOCA::Epetra::Group::getComplexMaps(
01341 Teuchos::RCP<const Epetra_BlockMap>& baseMap,
01342 Teuchos::RCP<const Epetra_BlockMap>& globalMap) const
01343 {
01344 baseMap = Teuchos::rcp(&(xVector.getEpetraVector().Map()),false);
01345 globalMap = Teuchos::rcp(&(complexVec->Map()),false);
01346 }