46 #include <Xyce_config.h>
49 #include <N_ERH_ErrorMgr.h>
50 #include <N_IO_OutputMgr.h>
51 #include <N_LAS_Builder.h>
52 #include <N_LAS_Matrix.h>
53 #include <N_LAS_System.h>
54 #include <N_LAS_Vector.h>
59 #include <N_UTL_FeatureTest.h>
62 #include <Teuchos_ParameterList.hpp>
63 #include <NOX_Abstract_Vector.H>
64 #include <LOCA_Parameter_Vector.H>
70 namespace N_NLS_LOCA {
81 N_NLS_NOX::SharedSystem& s, Loader::NonlinearEquationLoader& l,
82 IO::OutputMgr& o, Analysis::AnalysisManager & t) :
84 LOCA::Abstract::Group(gd),
91 useAugmentLinSys_(false),
97 nonContinuationSolve_(true)
99 tmpVectorPtr = sharedSystemPtr_->getLasSystem()->builder().createVector();
110 Group::Group(
const Group& source, NOX::CopyType type) :
111 N_NLS_NOX::
Group(source, type),
113 loader(source.loader),
114 outputMgr(source.outputMgr),
115 anaInt(source.anaInt),
116 params(source.params),
117 derivUtils(source.derivUtils),
119 scalingVecPtr(source.scalingVecPtr),
120 useAugmentLinSys_(source.useAugmentLinSys_),
121 outputLinear_(source.outputLinear_),
122 serialNumber_(source.serialNumber_),
123 oldSol_(source.oldSol_),
125 allNodes_(source.allNodes_),
126 #ifdef Xyce_PARALLEL_MPI
127 pdsCommPtr_(source.pdsCommPtr_),
129 augmentLSStrategy_(source.augmentLSStrategy_),
130 nonContinuationSolve_(source.nonContinuationSolve_)
156 NOX::Abstract::Group&
159 return operator=(dynamic_cast<const Group&>(source));
173 return operator=(dynamic_cast<const Group&>(source));
184 LOCA::Abstract::Group&
187 return operator=(dynamic_cast<const Group&>(source));
232 Teuchos::RCP<NOX::Abstract::Group>
Group::
235 Teuchos::RCP<Group> ptr =
236 Teuchos::rcp(
new Group(*
this, type));
256 for (
int i = 0; i <
params.length(); ++i) {
257 std::string label =
params.getLabel(i);
291 for (
int i = 0; i <
params.length(); ++i) {
292 std::string label =
params.getLabel(i);
301 NOX::Abstract::Group::ReturnType status =
306 Linear::Matrix& jacobian =
313 Linear::Matrix& jacobian =
315 dout() <<
"After computeJacobian, linear system is:" << std::endl;
338 NodeNameMap * allNodes,
339 N_PDS_Comm * pdsCommPtr)
357 Linear::Vector* solPtr_,
358 Linear::Vector* resPtr_)
360 NodeNameMap::iterator op_i;
361 NodeNameMap::iterator op_end;
362 int i, row, global_row;
364 std::vector<int> col;
365 std::vector<double> val;
366 std::map<int,std::string> rowOut;
372 #ifdef Xyce_PARALLEL_MPI
373 N_PDS_ParMap * pmap_;
374 pmap_ = resPtr_->pmap();
379 for ( ; op_i != op_end ; ++op_i)
381 std::ostringstream s;
382 row = (*op_i).second;
383 #ifdef Xyce_PARALLEL_MPI
384 global_row = pmap_->localToGlobalIndex(row);
388 s <<
"Global: " << global_row <<
" : " << (*op_i).first <<
" Row: " << global_row;
389 s <<
" Value: " << (*solPtr_)[row];
393 s <<
" Delta Value: " << (*solPtr_)[row] -
oldSol_[row];
396 oldSol_[row] = (*solPtr_)[row];
397 s <<
" Residual: " << (*resPtr_)[row];
398 #ifdef Xyce_PARALLEL_MPI
399 s <<
" proc: " << procID;
402 rowLen = jacobian->getLocalRowLength(row);
405 jacobian->getRowCopy(global_row, rowLen, rowLen, &val[0], &col[0]);
406 for (i=0 ; i<rowLen ; i++)
408 if (i>1 && i%10 == 0)
411 s <<
" " << GID <<
"(" << val[i] <<
")";
413 rowOut[global_row] = s.str();
416 std::map<int,std::string>::iterator row_i;
417 std::map<int,std::string>::iterator row_end = rowOut.end();
418 row_i = rowOut.begin();
420 #ifdef Xyce_PARALLEL_MPI
429 if (row_i == row_end)
436 str = (*row_i).second;
437 num = (*row_i).first;
439 #ifdef Xyce_PARALLEL_MPI
458 dout() << buf << std::endl;
461 dout() << str << std::endl;
463 else if (procID == posG)
473 dout() << str << std::endl;
519 params.setValue(paramID, value);
533 return params.getValue(paramID);
547 params.setValue(paramID, value);
561 return params.getValue(paramID);
588 const std::string message =
"Group::getScaleVec() - scaling vector not set!";
589 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL, message);
603 NOX::Abstract::Group::ReturnType
607 Linear::Matrix& jacobian =
611 jacobian.scale(conParamValue);
613 (*tmpVectorPtr).addScalar(1.0 - conParamValue);
617 return NOX::Abstract::Group::Ok;
654 const double conParam)
const
685 dout() <<
"In Group::stepFailed" << std::endl;
701 dout() <<
"In Group::stepSucceeded" << std::endl;
703 #ifdef Xyce_UPDATED_LOCA
708 const std::string message =
"Group::stepSucceeded is not fully supported yet! Recompile without Xyce_UPDATED_LOCA defined\n";
709 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL, message);
722 const Teuchos::RCP<N_NLS_NOX::AugmentLinSys>& ls)
std::map< int, double > oldSol_
NOX::Abstract::Group::ReturnType augmentJacobianForHomotopy(double conParamValue)
NOX::Abstract::Group & operator=(const NOX::Abstract::Group &source)
Assignment Operator.
Pure virtual class to augment a linear system.
Teuchos::RCP< NOX::Abstract::Group > clone(NOX::CopyType type=NOX::DeepCopy) const
Cloning function.
Group(Teuchos::RCP< LOCA::GlobalData > globalData, N_NLS_NOX::SharedSystem &s, Xyce::Loader::NonlinearEquationLoader &l, Xyce::IO::OutputMgr &o, Xyce::Analysis::AnalysisManager &t)
Basic Constructor.
NOX::Abstract::Group::ReturnType computeF()
Xyce::Linear::Vector * getNativeVectorPtr()
double getParam(int paramID) const
const T & value(const ParameterBase &entity, const Descriptor &descriptor)
Returns the value of the parameter for the entity.
bool setParam(std::string &name, double val, bool overrideOriginal=false)
void setParam(int paramID, double value)
NOX::Abstract::Group::ReturnType computeJacobian()
Overloaded Jacobian evaluation routine.
Xyce::Linear::System * getLasSystem()
NOX::Abstract::Group::ReturnType computeJacobian()
void setOutputLinear(Xyce::NodeNameMap *op, Xyce::NodeNameMap *allNodes, N_PDS_Comm *pdsCommPtr)
NOX::Abstract::Group & operator=(const Group &source)
void printSolution(const double conParam) const
void copy(const NOX::Abstract::Group &source)
Special LOCA assignment operator.
void setScaleVec(const NOX::Abstract::Vector &s)
bool getNonContinuationFlag()
void outputLinearSystem_(Xyce::Linear::Matrix *jacobian, Xyce::Linear::Vector *solution, Xyce::Linear::Vector *residual_vector)
Xyce::Loader::NonlinearEquationLoader & loader
Keep a reference to the loader to set parameters.
const Xyce::Linear::Matrix & getJacobian() const
Teuchos::RCP< N_NLS_NOX::AugmentLinSys > augmentLSStrategy_
bool nonContinuationSolve_
Xyce::Analysis::AnalysisManager & anaInt
need xyce's time integration manager.
const NOX::Abstract::Vector & getScaleVec() const
LOCA::DerivUtils derivUtils
Utilities for computing derivatives.
void setNonContinuationFlag(bool value)
LOCA::ParameterVector params
Parameter vector container.
const NOX::Abstract::Vector * scalingVecPtr
LOCA Scaling Vector.
bool completeHomotopyStep(Loader::NonlinearEquationLoader &loader, const std::vector< std::string > ¶mNames, const std::vector< double > ¶mVals, Linear::Vector *solnVecPtr)
Xyce::NodeNameMap * allNodes_
bool failHomotopyStep(Loader::NonlinearEquationLoader &loader)
const LOCA::ParameterVector & getParams() const
void debugOutput1(Xyce::Linear::Matrix &jacobian, Xyce::Linear::Vector &rhs)
SharedSystem * sharedSystemPtr_
NOX::Abstract::Group::ReturnType computeF()
Overloaded function evluation routine.
void setAugmentLinearSystem(bool enable, const Teuchos::RCP< N_NLS_NOX::AugmentLinSys > &ls)
void setParams(const LOCA::ParameterVector &p)
Xyce::Linear::Vector * tmpVectorPtr
Temporary vector used for homotopy calculation.