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)
258 std::string label =
params.getLabel(i);
292 for (
int i = 0; i <
params.length(); ++i) {
293 std::string label =
params.getLabel(i);
302 NOX::Abstract::Group::ReturnType status =
307 Linear::Matrix& jacobian =
314 Linear::Matrix& jacobian =
316 dout() <<
"After computeJacobian, linear system is:" << std::endl;
339 (
const std::vector< int > & paramIDs,
340 NOX::Abstract::MultiVector & dfdp,
348 bool voltageLimterStatus = loader.getVoltageLimiterStatus();
351 loader.setVoltageLimiterStatus(
false);
353 LOCA::Abstract::Group::computeDfDpMulti (paramIDs, dfdp, isValidF);
356 loader.setVoltageLimiterStatus(voltageLimterStatus);
361 bool tmp = sharedSystemPtr_->computeDfDpMulti (paramIDs, dfdp, isValidF);
366 std::cout <<
"dfdp vector[0]:" <<std::endl;
367 NOX::Abstract::Vector *DFDP = &dfdp[0];
368 DFDP->print(std::cout);
370 std::cout <<
"dfdp vector[1]:" <<std::endl;
372 DFDP->print(std::cout);
375 return NOX::Abstract::Group::Ok;
387 NodeNameMap * allNodes,
388 N_PDS_Comm * pdsCommPtr)
406 Linear::Vector* solPtr_,
407 Linear::Vector* resPtr_)
409 NodeNameMap::iterator op_i;
410 NodeNameMap::iterator op_end;
411 int i, row, global_row;
413 std::vector<int> col;
414 std::vector<double> val;
415 std::map<int,std::string> rowOut;
421 #ifdef Xyce_PARALLEL_MPI
422 N_PDS_ParMap * pmap_;
423 pmap_ = resPtr_->pmap();
428 for ( ; op_i != op_end ; ++op_i)
430 std::ostringstream s;
431 row = (*op_i).second;
432 #ifdef Xyce_PARALLEL_MPI
433 global_row = pmap_->localToGlobalIndex(row);
437 s <<
"Global: " << global_row <<
" : " << (*op_i).first <<
" Row: " << global_row;
438 s <<
" Value: " << (*solPtr_)[row];
442 s <<
" Delta Value: " << (*solPtr_)[row] -
oldSol_[row];
445 oldSol_[row] = (*solPtr_)[row];
446 s <<
" Residual: " << (*resPtr_)[row];
447 #ifdef Xyce_PARALLEL_MPI
448 s <<
" proc: " << procID;
451 rowLen = jacobian->getLocalRowLength(row);
454 jacobian->getRowCopy(global_row, rowLen, rowLen, &val[0], &col[0]);
455 for (i=0 ; i<rowLen ; i++)
457 if (i>1 && i%10 == 0)
460 s <<
" " << GID <<
"(" << val[i] <<
")";
462 rowOut[global_row] = s.str();
465 std::map<int,std::string>::iterator row_i;
466 std::map<int,std::string>::iterator row_end = rowOut.end();
467 row_i = rowOut.begin();
469 #ifdef Xyce_PARALLEL_MPI
478 if (row_i == row_end)
485 str = (*row_i).second;
486 num = (*row_i).first;
488 #ifdef Xyce_PARALLEL_MPI
507 dout() << buf << std::endl;
510 dout() << str << std::endl;
512 else if (procID == posG)
522 dout() << str << std::endl;
568 params.setValue(paramID, value);
582 return params.getValue(paramID);
596 params.setValue(paramID, value);
610 return params.getValue(paramID);
637 const std::string message =
"Group::getScaleVec() - scaling vector not set!";
638 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL, message);
652 NOX::Abstract::Group::ReturnType
656 Linear::Matrix& jacobian =
660 jacobian.scale(conParamValue);
662 (*tmpVectorPtr).addScalar(1.0 - conParamValue);
666 return NOX::Abstract::Group::Ok;
703 const double conParam)
const
758 const Teuchos::RCP<N_NLS_NOX::AugmentLinSys>& ls)
std::map< int, double > oldSol_
NOX::Abstract::Group::ReturnType augmentJacobianForHomotopy(double conParamValue)
void preProcessContinuationStep(LOCA::Abstract::Iterator::StepStatus stepStatus)
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()
NOX::Abstract::Group::ReturnType computeDfDpMulti(const std::vector< int > ¶mIDs, NOX::Abstract::MultiVector &dfdp, bool isValidF)
Overloaded dfdp sensitivity calculation.
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 postProcessContinuationStep(LOCA::Abstract::Iterator::StepStatus stepStatus)
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.