Xyce  6.1
N_TIA_DataStore.h
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-2015 Sandia Corporation
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //-----------------------------------------------------------------------------
24 
25 //-----------------------------------------------------------------------------
26 // Filename : $RCSfile: N_TIA_DataStore.h,v $
27 //
28 // Purpose : This file handles the class that defines the data arrays
29 // needed for the time integration algorithms.
30 //
31 // Special Notes :
32 //
33 // Creator : Buddy Watts
34 //
35 // Creation Date : 6/1/00
36 //
37 // Revision Information:
38 // ---------------------
39 //
40 // Revision Number: $Revision: 1.115 $
41 //
42 // Revision Date : $Date: 2015/09/03 22:11:40 $
43 //
44 // Current Owner : $Author: rlschie $
45 //-----------------------------------------------------------------------------
46 
47 #ifndef Xyce_N_TIA_DataStore_h
48 #define Xyce_N_TIA_DataStore_h
49 
50 // ---------- Standard Includes ----------
51 #include <list>
52 #include <vector>
53 
54 // ---------- Xyce Includes ----------
55 #include <N_LAS_fwd.h>
56 #include <N_TIA_fwd.h>
57 
58 #include <N_TIA_TwoLevelError.h>
59 #include <N_UTL_IndexPair.h>
60 
61 namespace Xyce {
62 namespace TimeIntg {
63 
64 //-----------------------------------------------------------------------------
65 // Class : DataStore
66 // Purpose : This is the class for defining data arrays needed in the
67 // time integration algorithms.
68 // Special Notes :
69 // Creator : Buddy Watts, SNL
70 // Creation Date : 6/01/00
71 //-----------------------------------------------------------------------------
72 class DataStore
73 {
74  public:
75  DataStore(int solution_size, int state_size, int max_order, const Linear::System &linear_system, const Linear::Builder &linear_system_builder);
76  ~DataStore();
77 
78  void allocateSensitivityArrays(Linear::Builder &builder, int numParams);
80 
81  private:
82  DataStore(const DataStore& rhs);
83  DataStore &operator=(const DataStore& rhs);
84 
85  // DataStore Functions
86  public:
87  void initializeDataArrays();
88  void enableOrderOneStart();
89 
90  void updateSolDataArrays();
91  bool updateStateDataArrays();
92 
93  void outputSolDataArrays(std::ostream &os);
94  void setConstantHistory();
96  void setZeroHistory();
97  void setErrorWtVector(const TIAParams &tia_params);
98  double WRMS_errorNorm();
99 
100  double partialErrorNormSum();
101  double partialQErrorNormSum();
102 
103  double partialSum_m1(int currentOrder);
104  double partialSum_m2(int currentOrder);
105 
106  double globalLength ();
108 
109  void computeDivDiffsBlock(const std::list<IndexPair> & solGIDList,
110  const std::list<IndexPair> & staGIDList);
111 
112  void printOutPointers ();
113  bool equateTmpVectors ();
115 
116  void outputPredictedSolution(std::ostream &os);
117  void outputPredictedDerivative(std::ostream &os);
118 
119  void stepLinearCombo ();
120 
121  double partialSum_p1(int currentOrder, int maxOrder);
122  double partialSum_q1();
123 
124  double delta_x_errorNorm_m1();
125  double delta_x_errorNorm_m2();
126  double delta_x_errorNorm_p1();
127  double delta_x_errorNorm_q1();
128 
129  bool getSolnVarData( const int & gid, std::vector<double> & varData );
130  bool getStateVarData( const int & gid, std::vector<double> & varData );
131  bool setSolnVarData( const int & gid, const std::vector<double> & varData );
132  bool setStateVarData( const int & gid, const std::vector<double> & varData );
133  bool getStoreVarData( const int & gid, std::vector<double> & varData );
134  bool setStoreVarData( const int & gid, const std::vector<double> & varData );
135 
136  bool setNextSolVectorPtr (Linear::Vector * solVecPtr);
137  bool setNextSolVectorPtr (Linear::Vector & solVecPtr);// TT: added
138  bool unsetNextSolVectorPtr ();
139 
140  bool resetAll(double absolute_error_tolerance, double relative_error_tolerance);
141 
142  bool resetFastTimeData ();
143 
144 private:
146 
147  public:
148  const Linear::System & linearSystem_;
149 
150  // TIA Arrays (pointers) for Integration Solution Process:
151  unsigned int maxOrder;
152  unsigned int solutionSize;
153  unsigned int stateSize;
154 
155  // temporary vectors:
156  Linear::Vector * tmpSolVectorPtr;
157  Linear::Vector * tmpStaVectorPtr;
158  Linear::Vector * tmpStaDerivPtr;
159  Linear::Vector * tmpLeadCurrentVectorPtr;
160  Linear::Vector * tmpLeadDeltaVPtr;
161  Linear::Vector * tmpLeadCurrentQVectorPtr;
163 
164  Linear::Vector * tmpStaDivDiffPtr;
165  Linear::Vector * tmpStoVectorPtr;
166 
167  // Predictors
168  Linear::Vector * xn0Ptr;
169 
170  // Solutions:
171  Linear::Vector * currSolutionPtr;
172  Linear::Vector * lastSolutionPtr;
173  Linear::Vector * oldeSolutionPtr;
174  Linear::Vector * nextSolutionPtr;
175  Linear::Vector * flagSolutionPtr;
176 
177  Linear::Vector * savedNextSolutionPtr;
178 
179  // States:
180  Linear::Vector * currStatePtr;
181  Linear::Vector * lastStatePtr;
182  Linear::Vector * oldeStatePtr;
183  Linear::Vector * nextStatePtr;
184 
185  // Storage:
186  Linear::Vector * currStorePtr;
187  Linear::Vector * lastStorePtr;
188  Linear::Vector * oldeStorePtr;
189  Linear::Vector * nextStorePtr;
190 
191  // for lead current calculations. F component is
192  // held in the store vector, Q component is here
193  // Note: These will be removed when all lead current calc's
194  // are moved to their own vector.
195  Linear::Vector * currStoreLeadCurrQPtr;
196  Linear::Vector * lastStoreLeadCurrQPtr;
197  Linear::Vector * oldeStoreLeadCurrQPtr;
198  Linear::Vector * nextStoreLeadCurrQPtr;
199 
200  // Lead current and power vectors
201  Linear::Vector * currLeadCurrentPtr;
202  Linear::Vector * lastLeadCurrentPtr;
203  Linear::Vector * oldLeadCurrentPtr;
204  Linear::Vector * nextLeadCurrentPtr;
205 
206  Linear::Vector * currLeadDeltaVPtr;
207  Linear::Vector * lastLeadDeltaVPtr;
208  Linear::Vector * oldLeadDeltaVPtr;
209  Linear::Vector * nextLeadDeltaVPtr;
210 
211  // for lead current calculations. F component is
212  // held in the store vector, Q component is here
213  Linear::Vector * currLeadCurrentQPtr;
214  Linear::Vector * lastLeadCurrentQPtr;
215  Linear::Vector * oldLeadCurrentQPtr;
216  Linear::Vector * nextLeadCurrentQPtr;
217 
218  // sensitivity vectors:
219  std::vector<Linear::Vector*> sensRHSPtrVector;
220 
221  std::vector<Linear::Vector*> nextDfdpPtrVector;
222 
223  std::vector<Linear::Vector*> currDqdpPtrVector;
224  std::vector<Linear::Vector*> lastDqdpPtrVector;
225  std::vector<Linear::Vector*> oldeDqdpPtrVector;
226  std::vector<Linear::Vector*> nextDqdpPtrVector;
227 
228  std::vector<Linear::Vector*> nextDbdpPtrVector;
229 
230  std::vector<Linear::Vector*> currDXdpPtrVector;
231  std::vector<Linear::Vector*> lastDXdpPtrVector;
232  std::vector<Linear::Vector*> oldeDXdpPtrVector;
233  std::vector<Linear::Vector*> nextDXdpPtrVector;
234 
235  // matvecs:
236  std::vector<Linear::Vector*> currDQdxDXdpPtrVector;
237  std::vector<Linear::Vector*> lastDQdxDXdpPtrVector;
238  std::vector<Linear::Vector*> oldeDQdxDXdpPtrVector;
239  std::vector<Linear::Vector*> nextDQdxDXdpPtrVector;
240 
241  std::vector<Linear::Vector*> currDQdxDXdpDerivPtrVector;
242  std::vector<Linear::Vector*> lastDQdxDXdpDerivPtrVector;
243  std::vector<Linear::Vector*> oldeDQdxDXdpDerivPtrVector;
244  std::vector<Linear::Vector*> nextDQdxDXdpDerivPtrVector;
245 
246  // Derivatives of Solutions:
247  Linear::Vector * currSolutionDerivPtr;
248  Linear::Vector * lastSolutionDerivPtr;
249  Linear::Vector * oldeSolutionDerivPtr;
250  Linear::Vector * nextSolutionDerivPtr;
251 
252  // Derivatives of States:
253  Linear::Vector * currStateDerivPtr;
254  Linear::Vector * lastStateDerivPtr;
255  Linear::Vector * oldeStateDerivPtr;
256  Linear::Vector * nextStateDerivPtr;
257 
258  // Derivatives of Store for lead curent calculations
259  // Note: These will be removed when all lead current calc's
260  // are moved to their own vector.
261  Linear::Vector * currStoreLeadCurrQDerivPtr;
262  Linear::Vector * lastStoreLeadCurrQDerivPtr;
263  Linear::Vector * oldeStoreLeadCurrQDerivPtr;
264  Linear::Vector * nextStoreLeadCurrQDerivPtr;
265 
266  // Derivatives of Store for lead curent calculations
267  Linear::Vector * currLeadCurrentQDerivPtr;
268  Linear::Vector * lastLeadCurrentQDerivPtr;
269  Linear::Vector * oldLeadCurrentQDerivPtr;
270  Linear::Vector * nextLeadCurrentQDerivPtr;
271 
272 
273  // Derivatives of dq/dp for sensitivity calculations
274  std::vector<Linear::Vector*> currDqdpDerivPtrVector;
275  std::vector<Linear::Vector*> lastDqdpDerivPtrVector;
276  std::vector<Linear::Vector*> oldeDqdpDerivPtrVector;
277  std::vector<Linear::Vector*> nextDqdpDerivPtrVector;
278 
279  // Sensitivity residual matvec term:
280  Linear::Vector * resMatVecPtr;
281 
282  // Scaled Divided Differences
283  Linear::Vector * currSolutionDivDiffPtr;
284  Linear::Vector * lastSolutionDivDiffPtr;
285  Linear::Vector * oldeSolutionDivDiffPtr;
286  Linear::Vector * nextSolutionDivDiffPtr;
287 
288  // Scaled Divided Differences
289  Linear::Vector * currStateDivDiffPtr;
290  Linear::Vector * lastStateDivDiffPtr;
291  Linear::Vector * oldeStateDivDiffPtr;
292  Linear::Vector * nextStateDivDiffPtr;
293 
294  // Error Vectors
295  Linear::Vector * errWtVecPtr;
296  Linear::Vector * absErrTolPtr;
297  Linear::Vector * relErrTolPtr;
298 
299  // Jacobian and RHS
300  Linear::Matrix * JMatrixPtr;
301  Linear::Vector * RHSVectorPtr;
302  Linear::Vector * JdxpVectorPtr; // only used in the device manager for debug purposes these days.
303 
304  // NonLinear Solution Vectors
305  Linear::Vector * newtonCorrectionPtr;
306 
307  // Mask for error norms (to allow some equations not to take part in
308  // weighted norms)
309  Linear::Vector * deviceErrorWeightMask_;
310 
311  // limiter flag:
313 
314  // 2-level information:
315  std::vector<TwoLevelError> innerErrorInfoVec;
316 
317  // new-DAE data (originally from the new-DAE derrived class)
318  // Error Vectors
319  Linear::Vector * qErrWtVecPtr;
320 
321  // DAE formulation vectors
322  Linear::Vector * daeQVectorPtr;
323  Linear::Vector * daeFVectorPtr;
324  Linear::Vector * daeBVectorPtr;
325 
326  // voltage limiting vectors
327  Linear::Vector * dFdxdVpVectorPtr;
328  Linear::Vector * dQdxdVpVectorPtr;
329 
330  // DAE formulation matrices
331  Linear::Matrix * dQdxMatrixPtr;
332  Linear::Matrix * dFdxMatrixPtr;
333 
334  // temporary stop-gap, needed for sensitivity analysis.
335  //Linear::Matrix * saved_dQdxMatrixPtr;
336 
337  // HB temporary Matvec storage vectors
338  Linear::Vector * dQdxVecVectorPtr;
339  Linear::Vector * dFdxVecVectorPtr;
340 
341  // History arrays
342  std::vector<Linear::Vector*> xHistory;
343  std::vector<Linear::Vector*> qHistory;
344  std::vector<Linear::Vector*> sHistory; // state history
345  std::vector<Linear::Vector*> stoHistory; // store history
346  std::vector<Linear::Vector*> stoLeadCurrQHistory; // store history for lead current Q component.
347  std::vector<Linear::Vector*> leadCurrentHistory; // history for lead current Q component.
348  std::vector<Linear::Vector*> leadCurrentQHistory; // history for lead current Q component.
349  std::vector<Linear::Vector*> leadCurrentQDerivHistory; // history for lead current dQ/dt component.
350  std::vector<Linear::Vector*> leadDeltaVHistory; // history for junction voltage
351 
352  // sensitivity histories
353  std::vector< std::vector<Linear::Vector*> > dfdpHistory;
354  std::vector< std::vector<Linear::Vector*> > dqdpHistory;
355  std::vector< std::vector<Linear::Vector*> > dbdpHistory;
356  std::vector< std::vector<Linear::Vector*> > dXdpHistory;
357 
358  std::vector< std::vector<Linear::Vector*> > dQdxdXdpHistory;
359 
360  // Predictors
361  Linear::Vector * qn0Ptr;
362  Linear::Vector * qpn0Ptr;
363 
364  Linear::Vector * sn0Ptr;
365  Linear::Vector * spn0Ptr;
366 
367  Linear::Vector * ston0Ptr;
368  Linear::Vector * stopn0Ptr;
369 
370  Linear::Vector * stoQn0Ptr;
371  Linear::Vector * stoQpn0Ptr;
372 
373  Linear::Vector * leadCurrentn0Ptr;
374  Linear::Vector * leadCurrentpn0Ptr;
375 
376  Linear::Vector * leadCurrentQn0Ptr;
377  Linear::Vector * leadCurrentQpn0Ptr;
378  Linear::Vector * leadDeltaVn0Ptr;
379  Linear::Vector * leadDeltaVpn0Ptr;
380  Linear::Vector * leadCurrentQDerivn0Ptr;
381  Linear::Vector * leadCurrentQDerivpn0Ptr;
382 
383 
384  // Nonlinear solution vector:
385  Linear::Vector * qNewtonCorrectionPtr;
386  Linear::Vector * sNewtonCorrectionPtr;
387  Linear::Vector * stoNewtonCorrectionPtr;
393 
394  // Step-size selection temporary vectors
395  Linear::Vector * delta_x;
396  Linear::Vector * delta_q;
397 
398  // Temporary vectors for WaMPDE interpolation
399  Linear::Vector * tmpXn0APtr;
400  Linear::Vector * tmpXn0BPtr;
401 
402  // These are for MPDE fast time scale points
403  std::vector<double> timeSteps;
404  std::vector<bool> timeStepsBreakpointFlag;
405  std::vector<Linear::Vector*> fastTimeSolutionVec;
406  std::vector<Linear::Vector*> fastTimeStateVec;
407  std::vector<Linear::Vector*> fastTimeQVec;
408  std::vector<Linear::Vector*> fastTimeStoreVec;
409 
410  std::vector<double> objectiveVec_;
411  std::vector<double> dOdpVec_;
412  std::vector<double> dOdpAdjVec_;
413  std::vector<double> scaled_dOdpVec_;
414  std::vector<double> scaled_dOdpAdjVec_;
415  std::vector<double> paramOrigVals_;
416 
417 private:
418  std::vector<int> indexVVars;
419  std::vector<int> indexMaskedVars;
420 
421  double solsMaxValue;
422 
423  Linear::Vector * maxSolutionPtr;
424  Linear::Vector * relSolutionPtr;
425  int index;
426 
428 };
429 
430 } // namespace TimeIntg
431 } // namespace Xyce
432 
433 #endif // Xyce_N_TIA_DataStore_h
434 
Linear::Vector * lastSolutionPtr
std::vector< double > paramOrigVals_
const Linear::System & linearSystem_
std::vector< Linear::Vector * > fastTimeQVec
Linear::Vector * oldeSolutionDerivPtr
Linear::Vector * sNewtonCorrectionPtr
Linear::Vector * nextLeadCurrentQPtr
Linear::Vector * leadCurrentQn0Ptr
std::vector< double > timeSteps
std::vector< Linear::Vector * > oldeDXdpPtrVector
Linear::Vector * oldeStoreLeadCurrQDerivPtr
std::vector< int > indexMaskedVars
std::vector< Linear::Vector * > currDQdxDXdpDerivPtrVector
Linear::Vector * tmpLeadDeltaVPtr
Linear::Vector * lastLeadDeltaVPtr
std::vector< bool > timeStepsBreakpointFlag
std::vector< Linear::Vector * > nextDqdpPtrVector
std::vector< Linear::Vector * > oldeDqdpPtrVector
Linear::Vector * currStateDerivPtr
Linear::Vector * currStateDivDiffPtr
std::vector< std::vector< Linear::Vector * > > dQdxdXdpHistory
Linear::Vector * oldeSolutionDivDiffPtr
Linear::Vector * stoNewtonCorrectionPtr
Linear::Vector * qErrWtVecPtr
Pure virtual class to augment a linear system.
Linear::Vector * lastStateDerivPtr
Linear::Vector * nextSolutionDerivPtr
std::vector< double > dOdpVec_
std::vector< double > scaled_dOdpVec_
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< double > scaled_dOdpAdjVec_
std::vector< Linear::Vector * > leadDeltaVHistory
Linear::Vector * tmpSolVectorPtr
Linear::Vector * leadCurrentpn0Ptr
Linear::Vector * leadCurrentNewtonCorrectionPtr
std::vector< Linear::Vector * > nextDbdpPtrVector
double partialSum_m2(int currentOrder)
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< double > objectiveVec_
DataStore & operator=(const DataStore &rhs)
std::vector< Linear::Vector * > currDXdpPtrVector
std::vector< Linear::Vector * > leadCurrentHistory
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
Linear::Vector * tmpLeadCurrentVectorPtr
std::vector< std::vector< Linear::Vector * > > dbdpHistory
Linear::Vector * oldeStateDivDiffPtr
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
Linear::Vector * JdxpVectorPtr
std::vector< Linear::Vector * > currDqdpDerivPtrVector
Linear::Vector * leadCurrentQNewtonCorrectionPtr
Linear::Vector * errWtVecPtr
Linear::Vector * nextSolutionDivDiffPtr
std::vector< Linear::Vector * > leadCurrentQDerivHistory
Linear::Matrix * dFdxMatrixPtr
Linear::Matrix * JMatrixPtr
Linear::Vector * currLeadCurrentQDerivPtr
Linear::Vector * nextStatePtr
std::vector< Linear::Vector * > fastTimeStoreVec
std::vector< Linear::Vector * > leadCurrentQHistory
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
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
Linear::Vector * RHSVectorPtr
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< double > dOdpAdjVec_
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
Linear::Vector * relSolutionPtr
std::vector< Linear::Vector * > stoHistory
Linear::Vector * dFdxVecVectorPtr
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)
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
std::vector< Linear::Vector * > currDqdpPtrVector
std::vector< Linear::Vector * > stoLeadCurrQHistory
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