47 #include <Xyce_config.h>
54 #include <N_LAS_Builder.h>
55 #include <N_LAS_Matrix.h>
56 #include <N_LAS_MultiVector.h>
57 #include <N_LAS_System.h>
58 #include <N_LAS_Vector.h>
60 #include <N_UTL_fwd.h>
61 #include <N_UTL_DeleteList.h>
62 #include <N_UTL_Diagnostic.h>
63 #include <N_UTL_FeatureTest.h>
64 #include <N_UTL_MachDepParams.h>
81 const Linear::System & linear_system,
82 const Linear::Builder & linear_system_builder)
84 nextSolPtrSwitched_(false),
87 solutionSize(solution_size),
88 stateSize(state_size),
94 tmpLeadCurrentVectorPtr(0),
96 tmpLeadCurrentQVectorPtr(0),
97 tmpLeadCurrentQDerivVectorPtr(0),
104 savedNextSolutionPtr(0),
113 currStoreLeadCurrQPtr(0),
114 lastStoreLeadCurrQPtr(0),
115 oldeStoreLeadCurrQPtr(0),
116 nextStoreLeadCurrQPtr(0),
117 currStoreLeadCurrQDerivPtr(0),
118 lastStoreLeadCurrQDerivPtr(0),
119 oldeStoreLeadCurrQDerivPtr(0),
120 nextStoreLeadCurrQDerivPtr(0),
121 currLeadCurrentPtr(0),
122 lastLeadCurrentPtr(0),
123 oldLeadCurrentPtr(0),
124 nextLeadCurrentPtr(0),
125 currLeadDeltaVPtr(0),
126 lastLeadDeltaVPtr(0),
128 nextLeadDeltaVPtr(0),
129 currLeadCurrentQPtr(0),
130 lastLeadCurrentQPtr(0),
131 oldLeadCurrentQPtr(0),
132 nextLeadCurrentQPtr(0),
133 currLeadCurrentQDerivPtr(0),
134 lastLeadCurrentQDerivPtr(0),
135 oldLeadCurrentQDerivPtr(0),
136 nextLeadCurrentQDerivPtr(0),
137 currSolutionDerivPtr(0),
138 lastSolutionDerivPtr(0),
139 oldeSolutionDerivPtr(0),
140 nextSolutionDerivPtr(0),
141 currStateDerivPtr(0),
142 lastStateDerivPtr(0),
143 oldeStateDerivPtr(0),
144 nextStateDerivPtr(0),
146 currSolutionDivDiffPtr(0),
147 lastSolutionDivDiffPtr(0),
148 oldeSolutionDivDiffPtr(0),
149 nextSolutionDivDiffPtr(0),
150 currStateDivDiffPtr(0),
151 lastStateDivDiffPtr(0),
152 oldeStateDivDiffPtr(0),
153 nextStateDivDiffPtr(0),
160 newtonCorrectionPtr(0),
161 deviceErrorWeightMask_(0),
180 leadCurrentpn0Ptr(0),
181 leadCurrentQn0Ptr(0),
182 leadCurrentQpn0Ptr(0),
183 leadCurrentQDerivn0Ptr(0),
184 leadCurrentQDerivpn0Ptr(0),
187 qNewtonCorrectionPtr(0),
188 sNewtonCorrectionPtr(0),
189 stoNewtonCorrectionPtr(0),
190 stoLeadCurrQNewtonCorrectionPtr(0),
191 leadCurrentNewtonCorrectionPtr(0),
192 leadCurrentQNewtonCorrectionPtr(0),
193 leadCurrentQDerivNewtonCorrectionPtr(0),
194 leadDeltaVNewtonCorrectionPtr(0),
205 allocateSensitivityArraysComplete(false)
218 xn0Ptr = linear_system_builder.createVector();
227 currStatePtr = linear_system_builder.createStateVector();
228 lastStatePtr = linear_system_builder.createStateVector();
229 nextStatePtr = linear_system_builder.createStateVector();
232 currStorePtr = linear_system_builder.createStoreVector();
233 lastStorePtr = linear_system_builder.createStoreVector();
234 nextStorePtr = linear_system_builder.createStoreVector();
283 errWtVecPtr = linear_system_builder.createVector();
318 for (
int i = 0; i < max_order + 1; ++i)
320 xHistory.push_back(linear_system_builder.createVector());
321 qHistory.push_back(linear_system_builder.createVector());
322 sHistory.push_back(linear_system_builder.createStateVector());
323 stoHistory.push_back(linear_system_builder.createStoreVector());
332 qn0Ptr = linear_system_builder.createVector();
333 qpn0Ptr = linear_system_builder.createVector();
334 sn0Ptr = linear_system_builder.createStateVector();
335 spn0Ptr = linear_system_builder.createStateVector();
336 ston0Ptr = linear_system_builder.createStoreVector();
337 stopn0Ptr = linear_system_builder.createStoreVector();
338 stoQn0Ptr = linear_system_builder.createStoreVector();
339 stoQpn0Ptr = linear_system_builder.createStoreVector();
360 delta_x = linear_system_builder.createVector();
361 delta_q = linear_system_builder.createVector();
364 tmpXn0APtr = linear_system_builder.createVector();
365 tmpXn0BPtr = linear_system_builder.createVector();
553 for (
int ip=0;ip<numParams;++ip)
682 for (
int ip=0;ip<numParams;++ip)
711 for (
int i = 0; i <
maxOrder + 1; ++i)
759 if (DEBUG_TIME && isActive(Diag::TIME_HISTORY))
760 Xyce::dout() <<
"\nDataStore::setConstantHistory" << std::endl;
856 double absolute_error_tolerance,
857 double relative_error_tolerance)
911 if (DEBUG_TIME && isActive(Diag::TIME_STEP))
913 Xyce::dout() <<
"\nDataStore::updateSolDataArrays " << std::endl;
995 for (
int ip=0;ip<iparamSizeQ;++ip)
1004 for (
int ip=0;ip<iparamSizeQderiv;++ip)
1013 for (
int ip=0;ip<iparamSizeX;++ip)
1022 for (
int ip=0;ip<iparamSizeQX;++ip)
1032 for (
int ip=0;ip<iparamSizeQXd;++ip)
1073 if (DEBUG_TIME && isActive(Diag::TIME_STEP))
1074 Xyce::dout() <<
"\nDataStore::updateStateDataArrays " << std::endl;
1153 << Xyce::section_divider << std::endl
1155 <<
" Solution Vectors:\n Current Last Olde Error" << std::endl;
1162 os << Xyce::section_divider << std::endl;
1236 for (
int ip=0;ip<iparamSizeQ;++ip)
1245 for (
int ip=0;ip<iparamSizeQ;++ip)
1254 for (
int ip=0;ip<iparamSizeX;++ip)
1263 for (
int ip=0;ip<iparamSizeQX;++ip)
1273 for (
int ip=0;ip<iparamSizeQX;++ip)
1293 os << Xyce::subsection_divider << std::endl
1294 <<
" Predicted Solution:" << std::endl;
1299 os << Xyce::subsection_divider << std::endl;
1312 os << Xyce::subsection_divider << std::endl
1313 <<
" Predicted Derivative:" << std::endl;
1318 os << Xyce::subsection_divider << std::endl;
1340 double errorNorm = 0.0;
1342 double sum = errorNorm*errorNorm;
1397 const std::list<IndexPair> & solGIDList,
1398 const std::list<IndexPair> & staGIDList)
1446 bool bsuccess =
true;
1538 if (DEBUG_TIME && isActive(Diag::TIME_HISTORY))
1539 Xyce::dout() <<
"\nDataStore::setZeroHistory" << std::endl;
1611 int sizeOfHistory =
xHistory.size();
1612 for (
int i = 0; i < sizeOfHistory; ++i)
1626 std::vector<Linear::Vector *> dfdp =
dfdpHistory[ip];
1627 std::vector<Linear::Vector *> dqdp =
dqdpHistory[ip];
1628 std::vector<Linear::Vector *> dbdp =
dbdpHistory[ip];
1629 std::vector<Linear::Vector *> dXdp =
dXdpHistory[ip];
1632 dfdp[i]->putScalar(0.0);
1633 dqdp[i]->putScalar(0.0);
1634 dbdp[i]->putScalar(0.0);
1635 dXdp[i]->putScalar(0.0);
1636 dQdxdXdp[i]->putScalar(0.0);
1667 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1669 Xyce::dout() << Xyce::section_divider << std::endl
1670 <<
"DataStore::setErrorWtVector" << std::endl << std::endl
1671 <<
" errorWtVector currSolution relErrorTol absErrorTol" << std::endl
1672 <<
" -------------- -------------- -------------- --------------" << std::endl;
1676 switch(tia_params.
newLte )
1682 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1684 double currMaxValue = 0.0;
1686 std::vector<int>
index(1, -1);
1688 Xyce::dout() <<
"currMaxValueoldLte = " << currMaxValue <<
", currMaxValueIndex = " << index[0] << std::endl;
1690 std::cout <<
" old LTE rel reference:" << std::endl;
1700 double currMaxValue = 0.0;
1707 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1709 std::vector<int>
index(1, -1);
1711 Xyce::dout() <<
"currMaxValue = " << currMaxValue <<
", currMaxValueIndex = " << index[0] << std::endl;
1713 std::cout <<
" lte =1 rel reference:" << std::endl;
1716 std::cout <<
" lte = 1 currSolution :" << std::endl;
1725 double currMaxValue = 0.0;
1728 std::vector<int> currIndex(1, -1);
1735 index = currIndex[0];
1741 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1743 Xyce::dout() <<
"signal global MaxValue = " <<
solsMaxValue <<
", signal global MaxValueIndex = " <<
index << std::endl;
1744 Xyce::dout() <<
" currMaxValue = " << currMaxValue <<
", currMaxValueIndex = " << currIndex[0] << std::endl;
1766 (*relSolutionPtr)[i] = (*maxSolutionPtr)[i];
1769 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1771 std::cout <<
" LTE 3 rel reference:" << std::endl; std::cout <<
" LTE 3 rel reference:" << std::endl;
1774 std::cout <<
" LTE = 3 next solutions :" << std::endl;
1782 std::cout <<
"Unsupported new LTE options" << std::endl;
1789 for (std::vector<int>::const_iterator it =
indexVVars.begin(), end =
indexVVars.end(); it != end; ++it)
1792 (*errWtVecPtr)[i] = (*relErrTolPtr)[i] * (*relSolutionPtr)[i] + (*absErrTolPtr)[i];
1793 (*qErrWtVecPtr)[i] = (*relErrTolPtr)[i] * (*qErrWtVecPtr)[i] + (*absErrTolPtr)[i];
1804 (*errWtVecPtr)[i] = (*qErrWtVecPtr)[i] = Util::MachineDependentParams::MachineBig();
1808 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1811 Xyce::dout() << (*errWtVecPtr)[k] <<
" "
1812 << (*currSolutionPtr)[k] <<
" "
1813 << (*relErrTolPtr)[k] <<
" "
1814 << (*absErrTolPtr)[k] <<
" " << std::endl;
1816 Xyce::dout() <<
"" << std::endl
1817 << Xyce::section_divider << std::endl;
1831 double errorNorm = 0.0, qErrorNorm = 0.0;
1835 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1837 Xyce::dout() <<
"DataStore::errorNorm = " << errorNorm << std::endl;
1838 Xyce::dout() <<
"DataStore::qErrorNorm = " << qErrorNorm << std::endl;
1850 double totalSize = upperSize;
1851 double totalSum = errorNorm*errorNorm*upperSize;
1852 double totalQSum = qErrorNorm*qErrorNorm*upperSize;
1854 for (
int i=0;i<sumSize;++i)
1860 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1862 Xyce::dout() <<
"DSdae:innerSum["<<i<<
"] = " << innerSum <<std::endl;
1863 Xyce::dout() <<
"DSdae:innerQSum["<<i<<
"] = " << innerQSum <<std::endl;
1864 Xyce::dout() <<
"DSdae:innerSize["<<i<<
"] = " << innerSize <<std::endl;
1867 totalSize += innerSize;
1868 totalSum += innerSum;
1869 totalQSum += innerQSum;
1872 double recip = 1.0/totalSize;
1873 errorNorm = sqrt(recip*totalSum);
1874 qErrorNorm = sqrt(recip*totalQSum);
1876 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
1878 Xyce::dout() <<
"DSdae:upperSize = " << upperSize << std::endl;
1879 Xyce::dout() <<
"DSdae:totalSum = " << totalSum << std::endl;
1880 Xyce::dout() <<
"DSdae:totalQSum = " << totalQSum << std::endl;
1881 Xyce::dout() <<
"DSdae:totalSize = " << totalSize << std::endl;
1882 Xyce::dout() <<
"DSdae:2-level errorNorm = " << errorNorm << std::endl;
1883 Xyce::dout() <<
"DSdae:2-level qErrorNorm = " << qErrorNorm << std::endl;
1910 double qErrorNorm = 0.0;
1912 double sum = qErrorNorm*qErrorNorm;
2009 if (currentOrder<maxOrder)
2063 double errorNorm = 0.0;
2073 double totalSize = upperSize;
2074 double totalSum = errorNorm*errorNorm*upperSize;
2076 for (
int i=0;i<sumSize;++i)
2081 totalSize += innerSize;
2082 totalSum += innerSum;
2085 double recip = 1.0/totalSize;
2086 errorNorm = sqrt(recip*totalSum);
2102 double errorNorm = 0.0;
2112 double totalSize = upperSize;
2113 double totalSum = errorNorm*errorNorm*upperSize;
2115 for (
int i=0;i<sumSize;++i)
2120 totalSize += innerSize;
2121 totalSum += innerSum;
2124 double recip = 1.0/totalSize;
2125 errorNorm = sqrt(recip*totalSum);
2141 double errorNorm = 0.0;
2151 double totalSize = upperSize;
2152 double totalSum = errorNorm*errorNorm*upperSize;
2154 for (
int i=0;i<sumSize;++i)
2159 totalSize += innerSize;
2160 totalSum += innerSum;
2163 double recip = 1.0/totalSize;
2164 errorNorm = sqrt(recip*totalSum);
2180 double errorNorm = 0.0;
2190 double totalSize = upperSize;
2191 double totalSum = errorNorm*errorNorm*upperSize;
2193 for (
int i=0;i<sumSize;++i)
2198 totalSize += innerSize;
2199 totalSum += innerSum;
2202 double recip = 1.0/totalSize;
2203 errorNorm = sqrt(recip*totalSum);
2241 if (DEBUG_TIME && isActive(Diag::TIME_ERROR))
2243 Xyce::dout() <<
"\n newtonCorrection: \n" << std::endl;
2245 Xyce::dout() << std::endl;
2246 Xyce::dout() <<
"\n qNewtonCorrection: \n" << std::endl;
2248 Xyce::dout() <<
"\n sNewtonCorrection: \n" << std::endl;
2250 Xyce::dout() << std::endl;
2265 std::vector<double> & varData )
2279 varData[i++] =
errWtVecPtr->getElementByGlobalIndex( gid );
2280 varData[i++] =
absErrTolPtr->getElementByGlobalIndex( gid );
2281 varData[i++] =
relErrTolPtr->getElementByGlobalIndex( gid );
2283 varData[i++] =
qErrWtVecPtr->getElementByGlobalIndex ( gid );
2284 varData[i++] =
daeQVectorPtr->getElementByGlobalIndex ( gid );
2285 varData[i++] =
daeFVectorPtr->getElementByGlobalIndex ( gid );
2286 varData[i++] =
daeBVectorPtr->getElementByGlobalIndex ( gid );
2287 varData[i++] =
xn0Ptr->getElementByGlobalIndex ( gid );
2288 varData[i++] =
qn0Ptr->getElementByGlobalIndex ( gid );
2289 varData[i++] =
qpn0Ptr->getElementByGlobalIndex ( gid );
2304 std::vector<double> & varData )
2307 varData.resize( 14 );
2311 varData[i++] =
currStatePtr->getElementByGlobalIndex( gid );
2312 varData[i++] =
lastStatePtr->getElementByGlobalIndex( gid );
2313 varData[i++] =
nextStatePtr->getElementByGlobalIndex( gid );
2320 varData[i++] =
sn0Ptr->getElementByGlobalIndex( gid );
2321 varData[i++] =
spn0Ptr->getElementByGlobalIndex( gid );
2335 std::vector<double> & varData )
2338 varData.resize( 6 );
2340 varData[i++] =
currStorePtr->getElementByGlobalIndex( gid );
2341 varData[i++] =
lastStorePtr->getElementByGlobalIndex( gid );
2342 varData[i++] =
nextStorePtr->getElementByGlobalIndex( gid );
2343 varData[i++] =
ston0Ptr->getElementByGlobalIndex( gid );
2344 varData[i++] =
stopn0Ptr->getElementByGlobalIndex( gid );
2357 const std::vector<double> & varData )
2370 errWtVecPtr->setElementByGlobalIndex ( gid, varData[i++] );
2371 absErrTolPtr->setElementByGlobalIndex ( gid, varData[i++] );
2372 relErrTolPtr->setElementByGlobalIndex ( gid, varData[i++] );
2374 qErrWtVecPtr->setElementByGlobalIndex ( gid, varData[i++] );
2375 daeQVectorPtr->setElementByGlobalIndex ( gid, varData[i++] );
2376 daeFVectorPtr->setElementByGlobalIndex ( gid, varData[i++] );
2377 daeBVectorPtr->setElementByGlobalIndex ( gid, varData[i++] );
2378 xn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2379 qn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2380 qpn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2395 const std::vector<double> & varData )
2401 currStatePtr->setElementByGlobalIndex ( gid, varData[i++] );
2402 lastStatePtr->setElementByGlobalIndex ( gid, varData[i++] );
2403 nextStatePtr->setElementByGlobalIndex ( gid, varData[i++] );
2411 sn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2412 spn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2425 const std::vector<double> & varData )
2429 currStorePtr->setElementByGlobalIndex ( gid, varData[i++] );
2430 lastStorePtr->setElementByGlobalIndex ( gid, varData[i++] );
2431 nextStorePtr->setElementByGlobalIndex ( gid, varData[i++] );
2432 ston0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
2433 stopn0Ptr->setElementByGlobalIndex ( gid, varData[i++] );
Linear::Vector * lastSolutionPtr
std::vector< Linear::Vector * > fastTimeQVec
Linear::Vector * oldeSolutionDerivPtr
Linear::Vector * sNewtonCorrectionPtr
Linear::Vector * nextLeadCurrentQPtr
Linear::Vector * leadCurrentQn0Ptr
std::vector< double > timeSteps
double delta_x_errorNorm_p1()
std::vector< Linear::Vector * > oldeDXdpPtrVector
Linear::Vector * oldeStoreLeadCurrQDerivPtr
std::vector< int > indexMaskedVars
std::vector< Linear::Vector * > currDQdxDXdpDerivPtrVector
double partialErrorNormSum()
Linear::Vector * tmpLeadDeltaVPtr
Linear::Vector * lastLeadDeltaVPtr
std::vector< bool > timeStepsBreakpointFlag
std::vector< Linear::Vector * > nextDqdpPtrVector
std::vector< Linear::Vector * > oldeDqdpPtrVector
Linear::Vector * currStateDerivPtr
bool usePreviousSolAsPredictor()
Linear::Vector * currStateDivDiffPtr
std::vector< std::vector< Linear::Vector * > > dQdxdXdpHistory
bool updateStateDataArrays()
Linear::Vector * oldeSolutionDivDiffPtr
Linear::Vector * stoNewtonCorrectionPtr
Linear::Vector * qErrWtVecPtr
Pure virtual class to augment a linear system.
Linear::Vector * lastStateDerivPtr
Linear::Vector * nextSolutionDerivPtr
bool resetAll(double absolute_error_tolerance, double relative_error_tolerance)
Linear::Vector * lastStoreLeadCurrQDerivPtr
Linear::Vector * lastStoreLeadCurrQPtr
void allocateSensitivityArrays(Linear::Builder &builder, int numParams)
std::vector< Linear::Vector * > nextDXdpPtrVector
Linear::Vector * tmpStaVectorPtr
void outputSolDataArrays(std::ostream &os)
Linear::Vector * currStorePtr
Linear::Vector * lastStatePtr
std::vector< Linear::Vector * > leadDeltaVHistory
Linear::Vector * tmpSolVectorPtr
double delta_x_errorNorm_m1()
Linear::Vector * leadCurrentpn0Ptr
Linear::Vector * leadCurrentNewtonCorrectionPtr
std::vector< Linear::Vector * > nextDbdpPtrVector
double partialSum_m2(int currentOrder)
bool allocateSensitivityArraysComplete
Linear::Vector * ston0Ptr
Linear::Vector * tmpStoVectorPtr
std::vector< Linear::Vector * > nextDfdpPtrVector
Linear::Vector * savedNextSolutionPtr
Linear::Vector * leadCurrentQDerivn0Ptr
std::vector< Linear::Vector * > nextDQdxDXdpDerivPtrVector
std::vector< Linear::Vector * > qHistory
std::vector< Linear::Vector * > fastTimeStateVec
Linear::Vector * nextLeadDeltaVPtr
Linear::Vector * currStatePtr
std::vector< Linear::Vector * > currDXdpPtrVector
std::vector< Linear::Vector * > leadCurrentHistory
void updateSolDataArrays()
void computeDividedDifferences()
std::vector< Linear::Vector * > fastTimeSolutionVec
Linear::Vector * leadDeltaVn0Ptr
std::vector< Linear::Vector * > oldeDQdxDXdpPtrVector
Linear::Vector * leadCurrentn0Ptr
Linear::Vector * oldeStatePtr
std::vector< TwoLevelError > innerErrorInfoVec
Linear::Vector * daeQVectorPtr
void setConstantHistory()
Linear::Vector * tmpLeadCurrentVectorPtr
std::vector< std::vector< Linear::Vector * > > dbdpHistory
Linear::Vector * oldeStateDivDiffPtr
void deleteSensitivityArrays()
double partialSum_p1(int currentOrder, int maxOrder)
Linear::Vector * tmpStaDerivPtr
Linear::Vector * lastLeadCurrentPtr
std::vector< Linear::Vector * > lastDQdxDXdpDerivPtrVector
Linear::Vector * deviceErrorWeightMask_
Linear::Vector * stopn0Ptr
void setErrorWtVector(const TIAParams &tia_params)
Linear::Vector * leadCurrentQpn0Ptr
std::vector< Linear::Vector * > oldeDqdpDerivPtrVector
Linear::Vector * oldeStoreLeadCurrQPtr
Linear::Vector * daeFVectorPtr
Linear::Vector * qNewtonCorrectionPtr
bool setStoreVarData(const int &gid, const std::vector< double > &varData)
Linear::Vector * currLeadCurrentQPtr
Linear::Vector * relErrTolPtr
bool getStateVarData(const int &gid, std::vector< double > &varData)
Linear::Vector * leadCurrentQDerivpn0Ptr
Linear::Vector * nextStoreLeadCurrQDerivPtr
std::vector< Linear::Vector * > currDqdpDerivPtrVector
Linear::Vector * leadCurrentQNewtonCorrectionPtr
Linear::Vector * errWtVecPtr
Linear::Vector * nextSolutionDivDiffPtr
std::vector< Linear::Vector * > leadCurrentQDerivHistory
Linear::Matrix * dFdxMatrixPtr
int maxOrder(const IO::CmdParse &command_line)
Linear::Vector * currLeadCurrentQDerivPtr
Linear::Vector * nextStatePtr
std::vector< Linear::Vector * > fastTimeStoreVec
std::vector< Linear::Vector * > leadCurrentQHistory
unsigned int solutionSize
Linear::Vector * oldeStateDerivPtr
std::vector< Linear::Vector * > nextDqdpDerivPtrVector
Linear::Vector * oldLeadCurrentPtr
Linear::Vector * oldLeadDeltaVPtr
Linear::Vector * dFdxdVpVectorPtr
std::vector< std::vector< Linear::Vector * > > dqdpHistory
Linear::Vector * currLeadDeltaVPtr
Linear::Vector * oldeSolutionPtr
double delta_x_errorNorm_q1()
void outputPredictedSolution(std::ostream &os)
Linear::Vector * currStoreLeadCurrQPtr
bool getSolnVarData(const int &gid, std::vector< double > &varData)
bool setSolnVarData(const int &gid, const std::vector< double > &varData)
Linear::Vector * tmpStaDivDiffPtr
Linear::Vector * stoLeadCurrQNewtonCorrectionPtr
std::vector< std::vector< Linear::Vector * > > dfdpHistory
void outputPredictedDerivative(std::ostream &os)
Linear::Vector * lastStateDivDiffPtr
Linear::Vector * nextSolutionPtr
double delta_x_errorNorm_m2()
void setConstantSensitivityHistory()
Linear::Vector * resMatVecPtr
Linear::Vector * tmpXn0BPtr
Linear::Vector * nextStorePtr
Linear::Vector * stoQn0Ptr
bool setStateVarData(const int &gid, const std::vector< double > &varData)
std::vector< Linear::Vector * > lastDqdpPtrVector
Linear::Vector * dQdxdVpVectorPtr
Linear::Vector * currSolutionDivDiffPtr
std::vector< Linear::Vector * > lastDqdpDerivPtrVector
Linear::Vector * lastSolutionDivDiffPtr
Linear::Vector * currLeadCurrentPtr
Linear::Vector * lastStorePtr
std::vector< Linear::Vector * > oldeDQdxDXdpDerivPtrVector
Linear::Vector * currSolutionDerivPtr
std::vector< Linear::Vector * > lastDQdxDXdpPtrVector
Linear::Vector * maxSolutionPtr
Linear::Vector * dQdxVecVectorPtr
Linear::Vector * lastLeadCurrentQDerivPtr
Linear::Vector * nextLeadCurrentQDerivPtr
bool setNextSolVectorPtr(Linear::Vector *solVecPtr)
Linear::Vector * tmpLeadCurrentQVectorPtr
Linear::Vector * newtonCorrectionPtr
Linear::Vector * tmpLeadCurrentQDerivVectorPtr
Linear::Vector * tmpXn0APtr
Linear::Vector * currSolutionPtr
std::vector< int > indexVVars
std::vector< Linear::Vector * > stoHistory
Linear::Vector * relSolutionPtr
Linear::Vector * dFdxVecVectorPtr
void enableOrderOneStart()
Linear::Vector * leadCurrentQDerivNewtonCorrectionPtr
Linear::Vector * stoQpn0Ptr
Linear::Vector * nextStoreLeadCurrQPtr
Linear::Vector * lastLeadCurrentQPtr
Linear::Vector * currStoreLeadCurrQDerivPtr
Linear::Vector * nextStateDerivPtr
Linear::Vector * oldLeadCurrentQPtr
std::vector< Linear::Vector * > xHistory
std::vector< Linear::Vector * > sensRHSPtrVector
bool getStoreVarData(const int &gid, std::vector< double > &varData)
bool unsetNextSolVectorPtr()
Linear::Vector * oldeStorePtr
DataStore(int solution_size, int state_size, int max_order, const Linear::System &linear_system, const Linear::Builder &linear_system_builder)
Linear::Vector * lastSolutionDerivPtr
Linear::Matrix * dQdxMatrixPtr
Linear::Vector * oldLeadCurrentQDerivPtr
Linear::Vector * flagSolutionPtr
Linear::Vector * nextStateDivDiffPtr
std::vector< Linear::Vector * > currDQdxDXdpPtrVector
double partialSum_m1(int currentOrder)
std::vector< std::vector< Linear::Vector * > > dXdpHistory
Linear::Vector * daeBVectorPtr
Linear::Vector * leadDeltaVpn0Ptr
std::vector< Linear::Vector * > nextDQdxDXdpPtrVector
Linear::Vector * leadDeltaVNewtonCorrectionPtr
Linear::Vector * absErrTolPtr
Linear::System & linearSystem_
std::vector< Linear::Vector * > currDqdpPtrVector
std::vector< Linear::Vector * > stoLeadCurrQHistory
double partialQErrorNormSum()
void computeDivDiffsBlock(const std::list< IndexPair > &solGIDList, const std::list< IndexPair > &staGIDList)
Linear::Vector * nextLeadCurrentPtr
std::vector< Linear::Vector * > lastDXdpPtrVector
std::vector< Linear::Vector * > sHistory