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.110.2.1 $
41 //
42 // Revision Date : $Date: 2015/04/02 18:20:18 $
43 //
44 // Current Owner : $Author: tvrusso $
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 unsetNextSolVectorPtr ();
138 
139  bool resetAll(double absolute_error_tolerance, double relative_error_tolerance);
140 
141  bool resetFastTimeData ();
142 
143 private:
145 
146  public:
147  const Linear::System & linearSystem_;
148 
149  // TIA Arrays (pointers) for Integration Solution Process:
150  unsigned int maxOrder;
151  unsigned int solutionSize;
152  unsigned int stateSize;
153 
154  // temporary vectors:
155  Linear::Vector * tmpSolVectorPtr;
156  Linear::Vector * tmpStaVectorPtr;
157  Linear::Vector * tmpStaDerivPtr;
158  Linear::Vector * tmpLeadCurrentVectorPtr;
159  Linear::Vector * tmpLeadDeltaVPtr;
160  Linear::Vector * tmpStaDivDiffPtr;
161 
162  Linear::Vector * tmpStoVectorPtr;
163 
164  // Predictors
165  Linear::Vector * xn0Ptr;
166 
167  // Solutions:
168  Linear::Vector * currSolutionPtr;
169  Linear::Vector * lastSolutionPtr;
170  Linear::Vector * oldeSolutionPtr;
171  Linear::Vector * nextSolutionPtr;
172  Linear::Vector * flagSolutionPtr;
173 
174  Linear::Vector * savedNextSolutionPtr;
175 
176  // States:
177  Linear::Vector * currStatePtr;
178  Linear::Vector * lastStatePtr;
179  Linear::Vector * oldeStatePtr;
180  Linear::Vector * nextStatePtr;
181 
182  // Storage:
183  Linear::Vector * currStorePtr;
184  Linear::Vector * lastStorePtr;
185  Linear::Vector * oldeStorePtr;
186  Linear::Vector * nextStorePtr;
187 
188  // for lead current calculations. F component is
189  // held in the store vector, Q component is here
190  // Note: These will be removed when all lead current calc's
191  // are moved to their own vector.
192  Linear::Vector * currStoreLeadCurrQPtr;
193  Linear::Vector * lastStoreLeadCurrQPtr;
194  Linear::Vector * oldeStoreLeadCurrQPtr;
195  Linear::Vector * nextStoreLeadCurrQPtr;
196 
197  // Lead current and power vectors
198  Linear::Vector * currLeadCurrentPtr;
199  Linear::Vector * lastLeadCurrentPtr;
200  Linear::Vector * oldLeadCurrentPtr;
201  Linear::Vector * nextLeadCurrentPtr;
202 
203  Linear::Vector * currLeadDeltaVPtr;
204  Linear::Vector * lastLeadDeltaVPtr;
205  Linear::Vector * oldLeadDeltaVPtr;
206  Linear::Vector * nextLeadDeltaVPtr;
207 
208  // for lead current calculations. F component is
209  // held in the store vector, Q component is here
210  Linear::Vector * currLeadCurrentQPtr;
211  Linear::Vector * lastLeadCurrentQPtr;
212  Linear::Vector * oldLeadCurrentQPtr;
213  Linear::Vector * nextLeadCurrentQPtr;
214 
215  // sensitivity vectors:
216  std::vector<Linear::Vector*> sensRHSPtrVector;
217 
218  std::vector<Linear::Vector*> nextDfdpPtrVector;
219 
220  std::vector<Linear::Vector*> currDqdpPtrVector;
221  std::vector<Linear::Vector*> lastDqdpPtrVector;
222  std::vector<Linear::Vector*> oldeDqdpPtrVector;
223  std::vector<Linear::Vector*> nextDqdpPtrVector;
224 
225  std::vector<Linear::Vector*> nextDbdpPtrVector;
226 
227  std::vector<Linear::Vector*> currDXdpPtrVector;
228  std::vector<Linear::Vector*> lastDXdpPtrVector;
229  std::vector<Linear::Vector*> oldeDXdpPtrVector;
230  std::vector<Linear::Vector*> nextDXdpPtrVector;
231 
232  // matvecs:
233  std::vector<Linear::Vector*> currDQdxDXdpPtrVector;
234  std::vector<Linear::Vector*> lastDQdxDXdpPtrVector;
235  std::vector<Linear::Vector*> oldeDQdxDXdpPtrVector;
236  std::vector<Linear::Vector*> nextDQdxDXdpPtrVector;
237 
238  std::vector<Linear::Vector*> currDQdxDXdpDerivPtrVector;
239  std::vector<Linear::Vector*> lastDQdxDXdpDerivPtrVector;
240  std::vector<Linear::Vector*> oldeDQdxDXdpDerivPtrVector;
241  std::vector<Linear::Vector*> nextDQdxDXdpDerivPtrVector;
242 
243  // Derivatives of Solutions:
244  Linear::Vector * currSolutionDerivPtr;
245  Linear::Vector * lastSolutionDerivPtr;
246  Linear::Vector * oldeSolutionDerivPtr;
247  Linear::Vector * nextSolutionDerivPtr;
248 
249  // Derivatives of States:
250  Linear::Vector * currStateDerivPtr;
251  Linear::Vector * lastStateDerivPtr;
252  Linear::Vector * oldeStateDerivPtr;
253  Linear::Vector * nextStateDerivPtr;
254 
255  // Derivatives of Store for lead curent calculations
256  // Note: These will be removed when all lead current calc's
257  // are moved to their own vector.
258  Linear::Vector * currStoreLeadCurrQDerivPtr;
259  Linear::Vector * lastStoreLeadCurrQDerivPtr;
260  Linear::Vector * oldeStoreLeadCurrQDerivPtr;
261  Linear::Vector * nextStoreLeadCurrQDerivPtr;
262 
263  // Derivatives of Store for lead curent calculations
264  Linear::Vector * currLeadCurrentQDerivPtr;
265  Linear::Vector * lastLeadCurrentQDerivPtr;
266  Linear::Vector * oldLeadCurrentQDerivPtr;
267  Linear::Vector * nextLeadCurrentQDerivPtr;
268 
269 
270  // Derivatives of dq/dp for sensitivity calculations
271  std::vector<Linear::Vector*> currDqdpDerivPtrVector;
272  std::vector<Linear::Vector*> lastDqdpDerivPtrVector;
273  std::vector<Linear::Vector*> oldeDqdpDerivPtrVector;
274  std::vector<Linear::Vector*> nextDqdpDerivPtrVector;
275 
276  // Sensitivity residual matvec term:
277  Linear::Vector * resMatVecPtr;
278 
279  // Scaled Divided Differences
280  Linear::Vector * currSolutionDivDiffPtr;
281  Linear::Vector * lastSolutionDivDiffPtr;
282  Linear::Vector * oldeSolutionDivDiffPtr;
283  Linear::Vector * nextSolutionDivDiffPtr;
284 
285  // Scaled Divided Differences
286  Linear::Vector * currStateDivDiffPtr;
287  Linear::Vector * lastStateDivDiffPtr;
288  Linear::Vector * oldeStateDivDiffPtr;
289  Linear::Vector * nextStateDivDiffPtr;
290 
291  // Error Vectors
292  Linear::Vector * errWtVecPtr;
293  Linear::Vector * absErrTolPtr;
294  Linear::Vector * relErrTolPtr;
295 
296  // Jacobian and RHS
297  Linear::Matrix * JMatrixPtr;
298  Linear::Vector * RHSVectorPtr;
299  Linear::Vector * JdxpVectorPtr; // only used in the device manager for debug purposes these days.
300 
301  // NonLinear Solution Vectors
302  Linear::Vector * newtonCorrectionPtr;
303 
304  // Mask for error norms (to allow some equations not to take part in
305  // weighted norms)
306  Linear::Vector * deviceErrorWeightMask_;
307 
308  // limiter flag:
310 
311  // 2-level information:
312  std::vector<TwoLevelError> innerErrorInfoVec;
313 
314  // new-DAE data (originally from the new-DAE derrived class)
315  // Error Vectors
316  Linear::Vector * qErrWtVecPtr;
317 
318  // DAE formulation vectors
319  Linear::Vector * daeQVectorPtr;
320  Linear::Vector * daeFVectorPtr;
321  Linear::Vector * daeBVectorPtr;
322 
323  // voltage limiting vectors
324  Linear::Vector * dFdxdVpVectorPtr;
325  Linear::Vector * dQdxdVpVectorPtr;
326 
327  // DAE formulation matrices
328  Linear::Matrix * dQdxMatrixPtr;
329  Linear::Matrix * dFdxMatrixPtr;
330 
331  // temporary stop-gap, needed for sensitivity analysis.
332  //Linear::Matrix * saved_dQdxMatrixPtr;
333 
334  // HB temporary Matvec storage vectors
335  Linear::Vector * dQdxVecVectorPtr;
336  Linear::Vector * dFdxVecVectorPtr;
337 
338  // History arrays
339  std::vector<Linear::Vector*> xHistory;
340  std::vector<Linear::Vector*> qHistory;
341  std::vector<Linear::Vector*> sHistory; // state history
342  std::vector<Linear::Vector*> stoHistory; // store history
343  std::vector<Linear::Vector*> stoLeadCurrQHistory; // store history for lead current Q component.
344  std::vector<Linear::Vector*> leadCurrentHistory; // history for lead current Q component.
345  std::vector<Linear::Vector*> leadCurrentQHistory; // history for lead current Q component.
346  std::vector<Linear::Vector*> leadDeltaVHistory; // history for junction voltage
347 
348  // sensitivity histories
349  std::vector< std::vector<Linear::Vector*> > dfdpHistory;
350  std::vector< std::vector<Linear::Vector*> > dqdpHistory;
351  std::vector< std::vector<Linear::Vector*> > dbdpHistory;
352  std::vector< std::vector<Linear::Vector*> > dXdpHistory;
353 
354  std::vector< std::vector<Linear::Vector*> > dQdxdXdpHistory;
355 
356  // Predictors
357  Linear::Vector * qn0Ptr;
358  Linear::Vector * qpn0Ptr;
359 
360  Linear::Vector * sn0Ptr;
361  Linear::Vector * spn0Ptr;
362 
363  Linear::Vector * ston0Ptr;
364  Linear::Vector * stopn0Ptr;
365 
366  Linear::Vector * stoQn0Ptr;
367  Linear::Vector * stoQpn0Ptr;
368 
369  Linear::Vector * leadCurrentn0Ptr;
370  Linear::Vector * leadCurrentpn0Ptr;
371 
372  Linear::Vector * leadCurrentQn0Ptr;
373  Linear::Vector * leadCurrentQpn0Ptr;
374  Linear::Vector * leadDeltaVn0Ptr;
375  Linear::Vector * leadDeltaVpn0Ptr;
376 
377 
378  // Nonlinear solution vector:
379  Linear::Vector * qNewtonCorrectionPtr;
380  Linear::Vector * sNewtonCorrectionPtr;
381  Linear::Vector * stoNewtonCorrectionPtr;
386 
387  // Step-size selection temporary vectors
388  Linear::Vector * delta_x;
389  Linear::Vector * delta_q;
390 
391  // Temporary vectors for WaMPDE interpolation
392  Linear::Vector * tmpXn0APtr;
393  Linear::Vector * tmpXn0BPtr;
394 
395  // These are for MPDE fast time scale points
396  std::vector<double> timeSteps;
397  std::vector<bool> timeStepsBreakpointFlag;
398  std::vector<Linear::Vector*> fastTimeSolutionVec;
399  std::vector<Linear::Vector*> fastTimeStateVec;
400  std::vector<Linear::Vector*> fastTimeQVec;
401  std::vector<Linear::Vector*> fastTimeStoreVec;
402 
403  std::vector<double> objectiveVec_;
404  std::vector<double> dOdpVec_;
405  std::vector<double> dOdpAdjVec_;
406  std::vector<double> scaled_dOdpVec_;
407  std::vector<double> scaled_dOdpAdjVec_;
408  std::vector<double> paramOrigVals_;
409 
410 private:
411  std::vector<int> indexVVars;
412  std::vector<int> indexMaskedVars;
413 };
414 
415 } // namespace TimeIntg
416 } // namespace Xyce
417 
418 #endif // Xyce_N_TIA_DataStore_h
419 
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
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 * nextStoreLeadCurrQDerivPtr
Linear::Vector * JdxpVectorPtr
std::vector< Linear::Vector * > currDqdpDerivPtrVector
Linear::Vector * leadCurrentQNewtonCorrectionPtr
Linear::Vector * errWtVecPtr
Linear::Vector * nextSolutionDivDiffPtr
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 * dQdxVecVectorPtr
Linear::Vector * lastLeadCurrentQDerivPtr
Linear::Vector * nextLeadCurrentQDerivPtr
bool setNextSolVectorPtr(Linear::Vector *solVecPtr)
Linear::Vector * newtonCorrectionPtr
Linear::Vector * tmpXn0APtr
Linear::Vector * currSolutionPtr
std::vector< int > indexVVars
std::vector< Linear::Vector * > stoHistory
Linear::Vector * dFdxVecVectorPtr
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