solver::Solver< nb_vars, identifier > Class Template Reference

Implement a set of solvers for ODE on a graph. More...

#include <algorithms/solver.h>

List of all members.

Public Types

typedef _EdgeInternals< nb_vars > EdgeInternals
 Type of the internals stored on the edges for some algorithms.
typedef util::Matrix< nb_vars,
nb_vars, double > 
Mat
 Type of a matrix used to store interaction on the edges.
typedef tag_holder< nb_vars,
identifier > 
tag_t
 Tag identifying this specific solver type.
typedef util::Vector< nb_vars,
double > 
Vec
 Type of a vector used to hold the data.
typedef _VertexInternals< nb_vars > VertexInternals
 Type of the internals stored on the vertices for some algorithms.

Public Member Functions

template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void FindPartials (const graph::Vertex< VertexContent > &v, graph::VVGraph< VertexContent, EdgeContent, compact > &S, double dt, int newtstep, Model &model)
 Find the partial derivative by successive approximation on each neighbors.
void initialize (bool update_dt=true)
 Initialize the solver.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void operator() (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, using the currently selected method.
void readParms (util::Parms &parms, const QString &section, bool selectAlgorithm=true)
 Read the parameters needed for the different algorithms,.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveAdaptiveCrankNicholson (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the adaptative Crank-Nicholson method.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveAdaptiveEuler (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the adaptative forward euler method.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveAdaptiveRungeKutta (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the adaptative order 4 runge-kutta method.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveEuler (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the forward euler method.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveFixedpoint (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the fixed point method.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveMidpoint (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the mid point method.
 Solver (util::Parms &parms, const QString &section, bool selectAlgorithm=true)
 Constructor reading the parameters instantly.
 Solver ()
 Default constructor.
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solveRungeKutta (graph::VVGraph< VertexContent, EdgeContent, compact > &S, Model &model)
 Invoke the solver, forcing the use of the order 4 runge-kutta method.

Public Attributes

bool initialized
 True if the solver is initialized.
Parameters for Adaptative Euler

double AEulerHighTol
 high water mark
double AEulerIncDt
 Dt increment.
double AEulerLowTol
 low water mark
double AEulerResDt
 Restart Dt decrement.
double AEulerResTol
 restart tolerance
ToleranceType AEulerTolType
 Type of the tolerance.
Adaptive Runge-Kutta parms

double ARungeHighTol
 high water mark
double ARungeIncDt
 Dt increment/decrement.
double ARungeLowTol
 low water mark
double ARungeResDt
 restart Dt decrement
double ARungeResTol
 restart tolerance
ToleranceType ARungeTolType
 Tolerence type.
Conjugate gradient params (used by Crank Nicholson)

double ConjGradMaxSteps
 Max steps for conjugate gradient (multiple of N).
double ConjGradTol
 Tolerence for conjugate gradient.
ToleranceType ConjGradTolType
 Tolerance type.
bool ConstNbPartials
 Set if partials to neighbors are constant (diffusion only).
Crank Nicholson params

double CRAvgCPU
 Weight of current dt in eff average.
double CRIncDt
 Increment for timestep based on efficiency (mulitple of current size).
double CRMinCPU
 Minimun CPU, below this alway increases timestep.
double CRResDt
 Decrement for timestep if unsucc.

SolvingMethod current_method
 Method currently used (i.e. it is set only after initialization).
double dt
 Current dt.
SolvingMethod method
 name Parameters
int PrintStats
 Level of debuging output.
int step
 Current computation step.
Misc general parms

double Dx
 Delta for numerical diff.
bool PrintMatrix
 Print Matrix (Conj-Grad).
Different Dt

double EulerDt
 Timestep for Forward Euler solver.
double FixedPointDt
 Timestep for FixedPoint iteration solver.
double InitialDt
 Timestep for adaptive solvers.
double MaxDt
 Maximum Dt for adapative solvers.
double MidPointDt
 Timestep for MultiPoint iteration solver.
double MinDt
 Minimum Dt for adapative solvers.
double RungeKuttaDt
 Timestep for Runge-Kutta solver.
Fixed Point iteration parms

double FixedPointMaxSteps
 Max steps for fixed point iteration.
double FixedPointTol
 Tolerance for fixed point iteration.
ToleranceType FixedPointTolType
 Type of tolerance.
Newton Tolerance (used by Crank Nicholson)

int NewtMaxSteps
 Max steps for Newton's method.
double NewtTol
 Tolerence for Newton's method.
ToleranceType NewtTolType
 Tolerance type.
Previous efficiency and dt for Cranck-Nicholson

double pdt
 Previous dt.
double peff
 Previous efficiency.

Detailed Description

template<size_t nb_vars, typename identifier = default_id_t>
class solver::Solver< nb_vars, identifier >

Implement a set of solvers for ODE on a graph.

The solver class implements 7 ODE algorithms:

  1. Forward Euler
  2. Adaptative forward Euler
  3. Fixed point
  4. Mid point
  5. Runge-Kutta order 4
  6. Adaptative Runge-Kutta order 4
  7. Adaptative Crank-Nicholson

Definition at line 396 of file solver.h.


Member Typedef Documentation

template<size_t nb_vars, typename identifier = default_id_t>
typedef _EdgeInternals<nb_vars> solver::Solver< nb_vars, identifier >::EdgeInternals

Type of the internals stored on the edges for some algorithms.

Definition at line 405 of file solver.h.

template<size_t nb_vars, typename identifier = default_id_t>
typedef util::Matrix<nb_vars,nb_vars,double> solver::Solver< nb_vars, identifier >::Mat

Type of a matrix used to store interaction on the edges.

Definition at line 401 of file solver.h.

template<size_t nb_vars, typename identifier = default_id_t>
typedef tag_holder<nb_vars,identifier> solver::Solver< nb_vars, identifier >::tag_t

Tag identifying this specific solver type.

Definition at line 408 of file solver.h.

template<size_t nb_vars, typename identifier = default_id_t>
typedef util::Vector<nb_vars, double> solver::Solver< nb_vars, identifier >::Vec

Type of a vector used to hold the data.

Definition at line 399 of file solver.h.

template<size_t nb_vars, typename identifier = default_id_t>
typedef _VertexInternals<nb_vars> solver::Solver< nb_vars, identifier >::VertexInternals

Type of the internals stored on the vertices for some algorithms.

Definition at line 403 of file solver.h.


Constructor & Destructor Documentation

template<size_t nb_vars, typename identifier = default_id_t>
solver::Solver< nb_vars, identifier >::Solver (  )  [inline]

Default constructor.

Definition at line 549 of file solver.h.

00550       : initialized(false)
00551       {}

template<size_t nb_vars, typename identifier = default_id_t>
solver::Solver< nb_vars, identifier >::Solver ( util::Parms parms,
const QString section,
bool  selectAlgorithm = true 
) [inline]

Constructor reading the parameters instantly.

Definition at line 554 of file solver.h.

References solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

00555       : initialized(false)
00556       {
00557         readParms(parms, section, selectAlgorithm);
00558         initialize();
00559       }


Member Function Documentation

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::FindPartials ( const graph::Vertex< VertexContent > &  v,
graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
double  dt,
int  newtstep,
Model model 
) [inline]

Find the partial derivative by successive approximation on each neighbors.

Definition at line 1115 of file solver.h.

References solver::Solver< nb_vars, identifier >::ConstNbPartials, solver::Solver< nb_vars, identifier >::Dx, forall, solver::Solver< nb_vars, identifier >::initialized, and graph::VVGraph< VertexContent, EdgeContent, compact >::neighbors().

Referenced by solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

01117     {
01118       if(!initialized)
01119       {
01120         cerr << "Error, trying to use uninitialized solver" << endl;
01121         return;
01122       }
01123       typedef graph::Vertex<VertexContent> vertex;
01124       // Save old vars and deltas
01125       VertexInternals& interns = model.vertexInternals(v, tag_t());
01126       model.updateDerivatives(v, tag_t());
01127       Vec ovars = model.values(v, tag_t());
01128       Vec odels = model.derivatives(v, tag_t());
01129 
01130       // Find partials for current node
01131       for(size_t i = 0; i < nb_vars; i++)
01132       {
01133         Vec& vars = model.values(v, tag_t());
01134         vars = ovars;
01135         vars[i] += Dx;
01136         model.updateDerivatives(v, tag_t());
01137         Vec dels = model.derivatives(v, tag_t());
01138         Vec partials = (dels - odels)/Dx * dt/2.0;
01139         partials[i] -= 1.0;
01140         interns.AT[i] = partials;
01141       }
01142       interns.AA = transpose(interns.AT);
01143       model.values(v, tag_t()) = ovars;
01144 
01145       // If only a diffusive interaction with neighbors, do not re-calc partials (constant)
01146       if(newtstep == 0 || !ConstNbPartials)
01147       {
01148         // Find partials for neighbors
01149         forall(const vertex& n, S.neighbors(v))
01150         {
01151           // Save velocity and postition and deltas
01152           Vec ovars = model.values(n, tag_t());
01153           EdgeInternals &einterns = model.edgeInternals(v,n,S, tag_t());
01154 
01155           // Find partials for current node
01156           for(size_t i = 0; i < nb_vars; i++)
01157           {
01158             Vec &vars = model.values(n, tag_t());
01159             vars = ovars;
01160             vars[i] += Dx;
01161             model.updateDerivatives(v, tag_t());
01162             Vec dels = model.derivatives(v, tag_t());
01163             Vec partials = (dels - odels)/Dx * dt/2.0;
01164             einterns.AT[i] = partials;
01165           }
01166           model.edgeInternals(n,v,S,tag_t()).AA = transpose(einterns.AT);
01167           model.values(n, tag_t()) = ovars;
01168         }
01169       }
01170       model.derivatives(v, tag_t()) = odels;
01171     }

template<size_t nb_vars, typename identifier = default_id_t>
void solver::Solver< nb_vars, identifier >::initialize ( bool  update_dt = true  )  [inline]

Initialize the solver.

Call this method after changing the solver type.

Definition at line 637 of file solver.h.

References solver::AdaptiveCrankNicholson, solver::AdaptiveEuler, solver::AdaptiveRungeKutta, solver::Solver< nb_vars, identifier >::current_method, solver::Solver< nb_vars, identifier >::dt, solver::Euler, solver::Solver< nb_vars, identifier >::EulerDt, solver::Fixedpoint, solver::Solver< nb_vars, identifier >::FixedPointDt, solver::Solver< nb_vars, identifier >::InitialDt, solver::Solver< nb_vars, identifier >::initialized, solver::Solver< nb_vars, identifier >::method, solver::Midpoint, solver::Solver< nb_vars, identifier >::MidPointDt, solver::Solver< nb_vars, identifier >::pdt, solver::Solver< nb_vars, identifier >::peff, solver::RungeKutta, solver::Solver< nb_vars, identifier >::RungeKuttaDt, and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::Solver().

00638     {
00639       if(update_dt or !initialized)
00640       {
00641         peff = 0;
00642         pdt = 0;
00643         step = 0;
00644         dt = 0;
00645       }
00646 
00647       current_method = method;
00648       switch(method)
00649       {
00650         case Euler:
00651           dt = EulerDt;
00652           break;
00653         case AdaptiveEuler:
00654           if(update_dt)
00655             dt = EulerDt;
00656           break;
00657         case Fixedpoint:
00658           dt = FixedPointDt;
00659           break;
00660         case Midpoint:
00661           dt = MidPointDt;
00662           break;
00663         case RungeKutta:
00664           dt = RungeKuttaDt;
00665           break;
00666         case AdaptiveRungeKutta:
00667         case AdaptiveCrankNicholson:
00668           if(update_dt or !initialized)
00669             dt = InitialDt;
00670           break;
00671       }
00672       initialized = true;
00673     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::operator() ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]
template<size_t nb_vars, typename identifier = default_id_t>
void solver::Solver< nb_vars, identifier >::readParms ( util::Parms parms,
const QString section,
bool  selectAlgorithm = true 
) [inline]

Read the parameters needed for the different algorithms,.

Parameters:
parms Parameter object pointing to the parameter file
section Section including the parameters for the solver
selectAlgorithm If true, the algorithm will be read from the parameter file.

Definition at line 568 of file solver.h.

References solver::Solver< nb_vars, identifier >::AEulerHighTol, solver::Solver< nb_vars, identifier >::AEulerIncDt, solver::Solver< nb_vars, identifier >::AEulerLowTol, solver::Solver< nb_vars, identifier >::AEulerResDt, solver::Solver< nb_vars, identifier >::AEulerResTol, solver::Solver< nb_vars, identifier >::AEulerTolType, solver::Solver< nb_vars, identifier >::ARungeHighTol, solver::Solver< nb_vars, identifier >::ARungeIncDt, solver::Solver< nb_vars, identifier >::ARungeLowTol, solver::Solver< nb_vars, identifier >::ARungeResDt, solver::Solver< nb_vars, identifier >::ARungeResTol, solver::Solver< nb_vars, identifier >::ARungeTolType, solver::Solver< nb_vars, identifier >::ConjGradMaxSteps, solver::Solver< nb_vars, identifier >::ConjGradTol, solver::Solver< nb_vars, identifier >::ConjGradTolType, solver::Solver< nb_vars, identifier >::ConstNbPartials, solver::Solver< nb_vars, identifier >::CRAvgCPU, solver::Solver< nb_vars, identifier >::CRIncDt, solver::Solver< nb_vars, identifier >::CRMinCPU, solver::Solver< nb_vars, identifier >::CRResDt, solver::Solver< nb_vars, identifier >::Dx, solver::Solver< nb_vars, identifier >::EulerDt, solver::Solver< nb_vars, identifier >::FixedPointDt, solver::Solver< nb_vars, identifier >::FixedPointMaxSteps, solver::Solver< nb_vars, identifier >::FixedPointTol, solver::Solver< nb_vars, identifier >::FixedPointTolType, solver::Solver< nb_vars, identifier >::InitialDt, solver::Solver< nb_vars, identifier >::initialize(), solver::Solver< nb_vars, identifier >::MaxDt, solver::Solver< nb_vars, identifier >::method, solver::Solver< nb_vars, identifier >::MidPointDt, solver::Solver< nb_vars, identifier >::NewtMaxSteps, solver::Solver< nb_vars, identifier >::NewtTol, solver::Solver< nb_vars, identifier >::NewtTolType, solver::Solver< nb_vars, identifier >::PrintMatrix, solver::Solver< nb_vars, identifier >::PrintStats, and solver::Solver< nb_vars, identifier >::RungeKuttaDt.

Referenced by solver::Solver< nb_vars, identifier >::Solver().

00569     {
00570       if(selectAlgorithm)
00571       {
00572         parms(section, "Solver", method);
00573         cout << "Solver selected: " << method << endl;
00574       }
00575 
00576       // Level of debuging output
00577       parms(section, "PrintStats", PrintStats);
00578 
00579       // Timesteps for the different algorithms
00580       parms(section, "EulerDt", EulerDt);
00581       parms(section, "FixedPointDt", FixedPointDt);
00582       parms(section, "MidPointDt", MidPointDt);
00583       parms(section, "RungeKuttaDt", RungeKuttaDt);
00584       parms(section, "InitialDt", InitialDt);
00585       parms(section, "MaxDt", MaxDt);
00586 
00587       // Parameters for Adaptative Euler
00588       parms(section, "AEulerTolType", AEulerTolType);
00589       parms(section, "AEulerIncDt", AEulerIncDt);
00590       parms(section, "AEulerResDt", AEulerResDt);
00591       parms(section, "AEulerResTol", AEulerResTol);
00592       parms(section, "AEulerLowTol", AEulerLowTol);
00593       parms(section, "AEulerHighTol", AEulerHighTol);
00594 
00595       // Fixed Point iteration parms
00596       parms(section, "FixedPointMaxSteps", FixedPointMaxSteps);
00597       parms(section, "FixedPointTol", FixedPointTol);
00598       parms(section, "FixedPointTolType", FixedPointTolType);
00599 
00600       // Adaptive Runge-Kutta parms
00601       parms(section, "ARungeIncDt", ARungeIncDt);
00602       parms(section, "ARungeResDt", ARungeResDt);
00603       parms(section, "ARungeTolType", ARungeTolType);
00604       parms(section, "ARungeResTol", ARungeResTol);
00605       parms(section, "ARungeLowTol", ARungeLowTol);
00606       parms(section, "ARungeHighTol", ARungeHighTol);
00607 
00608       // Crank Nicholson params
00609       parms(section, "CRIncDt", CRIncDt);
00610       parms(section, "CRResDt", CRResDt);
00611       parms(section, "CRAvgCPU", CRAvgCPU);
00612       parms(section, "CRMinCPU", CRMinCPU);
00613 
00614       // Newton Tolerance (used by Crank Nicholson)
00615       parms(section, "NewtTol", NewtTol);
00616       parms(section, "NewtTolType", NewtTolType);
00617       parms(section, "NewtMaxSteps", NewtMaxSteps);
00618 
00619       // Conjugate gradient params (used by Crank Nicholson)
00620       parms(section, "ConjGradTol", ConjGradTol);
00621       parms(section, "ConjGradTolType", ConjGradTolType);
00622       parms(section, "ConjGradMaxSteps", ConjGradMaxSteps);
00623       parms(section, "ConstNbPartials", ConstNbPartials);
00624 
00625       // Misc general parms
00626       parms(section, "Dx", Dx);
00627       parms(section, "PrintMatrix", PrintMatrix);
00628 
00629       initialize(false);
00630     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the adaptative Crank-Nicholson method.

Definition at line 1179 of file solver.h.

References solver::Solver< nb_vars, identifier >::ConjGradMaxSteps, solver::Solver< nb_vars, identifier >::ConjGradTol, solver::Solver< nb_vars, identifier >::ConjGradTolType, solver::Solver< nb_vars, identifier >::ConstNbPartials, solver::Solver< nb_vars, identifier >::CRAvgCPU, solver::Solver< nb_vars, identifier >::CRIncDt, solver::Solver< nb_vars, identifier >::CRMinCPU, solver::Solver< nb_vars, identifier >::CRResDt, solver::Solver< nb_vars, identifier >::dt, solver::Solver< nb_vars, identifier >::FindPartials(), forall, solver::Solver< nb_vars, identifier >::initialized, solver::MAX_COMPONENT, solver::Solver< nb_vars, identifier >::MaxDt, solver::MEAN_COMPONENT, graph::VVGraph< VertexContent, EdgeContent, compact >::neighbors(), solver::Solver< nb_vars, identifier >::NewtMaxSteps, solver::Solver< nb_vars, identifier >::NewtTol, solver::Solver< nb_vars, identifier >::NewtTolType, solver::Solver< nb_vars, identifier >::pdt, solver::Solver< nb_vars, identifier >::peff, solver::Solver< nb_vars, identifier >::PrintMatrix, solver::Solver< nb_vars, identifier >::PrintStats, graph::VVGraph< VertexContent, EdgeContent, compact >::size(), solver::Solver< nb_vars, identifier >::step, and util::Vector< dim, T >::x().

Referenced by solver::Solver< nb_vars, identifier >::operator()().

01180     {
01181       if(!initialized)
01182       {
01183         cerr << "Error, trying to use uninitialized solver" << endl;
01184         return;
01185       }
01186       typedef graph::Vertex<VertexContent> vertex;
01187       int conjGradMaxSteps = int(ConjGradMaxSteps*S.size());
01188       int newthalf = (int)(NewtMaxSteps/2.0);
01189       int cghalf = (int)(conjGradMaxSteps/2.0);
01190 
01191       int cgsteps = 0;
01192       int newtsteps = 0;
01193       long cpu = 0;
01194 
01195       double rr = 0;
01196       newtsteps = 0;
01197 
01198       // Back up data values in case of restart
01199       forall(const vertex& v, S)
01200       {
01201         model.vertexInternals(v, tag_t()).x0 = model.values(v, tag_t());
01202       }
01203 
01204       // Newton iteration
01205       bool restart = false;
01206       while(true)
01207       {
01208         if(restart)
01209         {
01210           cgsteps = newtsteps = 0;
01211           cpu = 1;
01212           dt *= CRResDt;
01213           restart = false;
01214           // Restore data
01215           forall(const vertex& v, S)
01216           {
01217             model.values(v, tag_t()) = model.vertexInternals(v, tag_t()).x0;
01218           }
01219         }
01220         if(newtsteps == 0)
01221         {
01222           // Find t0 values
01223           forall(const vertex& v, S)
01224           {
01225             model.updateDerivatives(v, tag_t());
01226             VertexInternals &interns = model.vertexInternals(v, tag_t());
01227             interns.t0 = model.derivatives(v, tag_t()) * dt/2.0;
01228             interns.t0 += interns.x0;
01229           }
01230         }
01231 
01232         // Initialize matrix A and vector b in Ax=b
01233         forall(const vertex& v, S)
01234         {
01235           FindPartials(v, S, dt, newtsteps, model);
01236           VertexInternals &interns = model.vertexInternals(v, tag_t());
01237           interns.b = (model.values(v, tag_t())
01238                        - model.derivatives(v, tag_t())*dt/2.0
01239                        - interns.t0);
01240         }
01241 
01242         newtsteps++;
01243 
01244         // Calculate cpu, add penalty for too many steps to avoid restart
01245         long newtcpu = 1;
01246         int newtover = newtsteps - newthalf;
01247         if(newtover > 1)
01248         {
01249           newtcpu += newtover;
01250           if(PrintStats >= 3)
01251             cout << "Newton step:" << newtsteps << " penalized by:" << newtover << endl;
01252         }
01253         if(!ConstNbPartials)
01254           newtcpu *= nb_vars;
01255         cpu += newtcpu;
01256 
01257         // Print matrix if required
01258         if(PrintMatrix)
01259         {
01260           cout << "Bi-conjugate Gradient Matrix" << endl;
01261           //PrintMatrix();
01262         }
01263 
01264         // Find first residual: Ax - b (note x = 0)
01265         rr = 0;
01266         double orr = 0;
01267         forall(const vertex& v, S)
01268         {
01269           VertexInternals &interns = model.vertexInternals(v, tag_t());
01270           interns.x = 0.0;
01271           interns.r1 = interns.r2 = -interns.b;
01272           interns.p1 = -interns.r1;
01273           interns.p2 = -interns.r2;
01274           rr += interns.r2 * interns.r1;
01275         }
01276 
01277         // Print out initial residual
01278         if(PrintStats >= 3)
01279           cout << "Bi-conjugate gradient initial residual:" << fabs(rr)/S.size() << " step size:" << dt << endl;
01280 
01281         // Main conj-grad iteration loop
01282         cgsteps = 0;
01283         double cgerr = 0;
01284         while(true)
01285         {
01286           cgsteps++;
01287 
01288           // Calculate cpu, add penalty for too many steps to avoid restart
01289           int cgcpu = 1;
01290           int cgover = cgsteps - cghalf;
01291           if(cgover > 1)
01292           {
01293             cgcpu += cgover;
01294             if(PrintStats >= 3)
01295               cout << "Bi-conjugate gradient step:" << cgsteps << " penalized by:" << cgover << endl;
01296           }
01297           cpu += cgcpu;
01298 
01299           // Find AAp1, ATp2, and p2AAp1
01300           double p2AAp1 = 0;
01301           forall(const vertex& v, S)
01302           {
01303             VertexInternals &v_interns = model.vertexInternals(v, tag_t());
01304             v_interns.AAp1 = v_interns.AA * v_interns.p1;
01305             v_interns.ATp2 = v_interns.AT * v_interns.p2;
01306             forall(const vertex& n, S.neighbors(v))
01307             {
01308               VertexInternals &n_interns = model.vertexInternals(n, tag_t());
01309               EdgeInternals &e_interns = model.edgeInternals(v, n, S, tag_t());
01310               v_interns.AAp1 += e_interns.AA * n_interns.p1;
01311               v_interns.ATp2 += e_interns.AT * n_interns.p2;
01312             }
01313             p2AAp1 += v_interns.p2 * v_interns.AAp1;
01314           }
01315 
01316           // Find coefficients for basis vectors (alpha)
01317           double alpha = rr / p2AAp1;
01318 
01319           // Find next solution, residual, error, and new rr
01320           orr = rr;
01321           rr = 0;
01322           cgerr = 0;
01323           forall(const vertex& v, S)
01324           {
01325             VertexInternals &interns = model.vertexInternals(v, tag_t());
01326             // Improve solution vector
01327             interns.x += alpha * interns.p1;
01328 
01329             // Next residual
01330             interns.r1 += alpha * interns.AAp1;
01331             interns.r2 += alpha * interns.ATp2;
01332             double res = interns.r2 * interns.r1;
01333             rr += res;
01334             res = fabs(res);
01335             switch(ConjGradTolType)
01336             {
01337               case MEAN_COMPONENT:
01338                 cgerr += res;
01339                 break;
01340               case MAX_COMPONENT:
01341               default:
01342                 if(res > cgerr)
01343                   cgerr = res;
01344             }
01345           }
01346           if(ConjGradTolType == MEAN_COMPONENT)
01347             cgerr /= S.size();
01348 
01349           // Calculate next vector
01350           double beta = rr/orr;
01351           forall(const vertex& v, S)
01352           {
01353             VertexInternals &interns = model.vertexInternals(v, tag_t());
01354             interns.p1 = beta * interns.p1 - interns.r1;
01355             interns.p2 = beta * interns.p2 - interns.r2;
01356           }
01357 
01358           // Print Stats
01359           if(PrintStats >= 3)
01360             cout << "Bi-conj grad step:" << cgsteps << " Residual:" << cgerr << endl;
01361 
01362           // Check if we are done
01363           if(cgerr < ConjGradTol)
01364             break;
01365 
01366           // Check if we need to restart
01367           if(cgsteps >= conjGradMaxSteps || isnan(cgerr) || !finite(cgerr))
01368           {
01369             if(PrintStats >= 1)
01370             {
01371               if(cgsteps >= conjGradMaxSteps)
01372                 cout << "Restarting step:" << step << ", Conj-Grad too many iterations at stepsize:" << dt << endl;
01373               else
01374                 cout << "Restarting step:" << step << ", Conj-Grad residual out of bounds" << endl;
01375             }
01376             restart = true;
01377             break;
01378           }
01379         }
01380 
01381         double newterr = 0.0;
01382         if(cgsteps > 0 && !restart)
01383         {
01384           // Update model values  
01385           forall(const vertex& v, S)
01386           {
01387             VertexInternals &interns = model.vertexInternals(v, tag_t());
01388             Vec &vars = model.values(v, tag_t());
01389             vars += interns.x;
01390             double corr = norm(interns.x);
01391             switch(NewtTolType)
01392             {
01393               case MEAN_COMPONENT:
01394                 newterr += corr;
01395                 break;
01396               case MAX_COMPONENT:
01397               default:
01398                 if(corr > newterr)
01399                   newterr = corr;
01400             }
01401           }
01402           if(NewtTolType == MEAN_COMPONENT)
01403             newterr /= S.size();
01404 
01405           if(PrintStats >= 2)
01406           {
01407             cout << "Newton step:" << newtsteps << " Corr Size:" << newterr << " ";
01408             cout << "Bi-Conj steps:" << cgsteps << " Residual:" << cgerr << endl;
01409           }
01410           if(newterr < NewtTol && !restart)
01411             break;
01412         }
01413 
01414         if(newtsteps >= NewtMaxSteps || isnan(newterr) || !finite(newterr))
01415         {
01416           if(PrintStats >= 1)
01417           {
01418             if(newtsteps >= NewtMaxSteps)
01419               cout << "Restarting:" << step << ", Newton iterations exceeded at stepsize:" << dt << endl;
01420             else
01421               cout << "Restarting:" << step << ", Newton correction out of bounds" << endl;
01422           }
01423           restart = true;
01424         }
01425       }
01426 
01427       // Adaptive stepsize based on cpu use
01428       double eff = dt/double(cpu);
01429       double inc = dt * CRIncDt;
01430       if(cpu > CRMinCPU)
01431       {
01432         if(peff > eff)
01433         {
01434           if(dt >= pdt)
01435             inc *= -1;
01436         }
01437         else
01438         {
01439           if(dt < pdt)
01440             inc *= -1;
01441         }
01442       }
01443 
01444       peff = (peff * (1.0 - CRAvgCPU) + CRAvgCPU * eff);
01445       pdt = dt;
01446 
01447       if(PrintStats >= 2)
01448         cout << "Stepsize:" << dt << ", current increment:" << inc << endl;
01449 
01450       dt += inc;
01451 
01452       if(dt > MaxDt)
01453         dt = MaxDt;
01454     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveAdaptiveEuler ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the adaptative forward euler method.

Definition at line 706 of file solver.h.

References solver::Solver< nb_vars, identifier >::AEulerHighTol, solver::Solver< nb_vars, identifier >::AEulerIncDt, solver::Solver< nb_vars, identifier >::AEulerLowTol, solver::Solver< nb_vars, identifier >::AEulerResDt, solver::Solver< nb_vars, identifier >::AEulerResTol, solver::Solver< nb_vars, identifier >::AEulerTolType, solver::Solver< nb_vars, identifier >::dt, forall, solver::Solver< nb_vars, identifier >::initialized, solver::MAX_COMPONENT, solver::Solver< nb_vars, identifier >::MaxDt, solver::MEAN_COMPONENT, solver::Solver< nb_vars, identifier >::MinDt, solver::Solver< nb_vars, identifier >::PrintStats, graph::VVGraph< VertexContent, EdgeContent, compact >::size(), and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00707     {
00708       if(!initialized)
00709       {
00710         cerr << "Error, trying to use uninitialized solver" << endl;
00711         return;
00712       }
00713       typedef graph::Vertex<VertexContent> vertex;
00714       double err = 0;
00715       forall(const vertex& v, S)
00716       {
00717         model.updateDerivatives(v, tag_t());
00718       }
00719       forall(const vertex& v, S)
00720       {
00721         VertexInternals& interns = model.vertexInternals(v, tag_t());
00722         Vec& vars = model.values(v, tag_t());
00723         const Vec& derivs = model.derivatives(v, tag_t());
00724         double derr = norm(derivs - interns.pDerivs);
00725         switch(AEulerTolType)
00726         {
00727           case MEAN_COMPONENT:
00728             err += derr;
00729             break;
00730           case MAX_COMPONENT:
00731           default:
00732             if(err < derr)
00733               err = derr;
00734         }
00735         vars += dt * derivs;
00736         interns.ppDerivs = interns.pDerivs;
00737         interns.pDerivs = derivs;
00738       }
00739       if(AEulerTolType == MEAN_COMPONENT)
00740         err /= S.size();
00741 
00742       if(step)
00743       {
00744         if(err > AEulerResTol && dt > MinDt)
00745         { // Backup a step and restart
00746           forall( vertex v, S )
00747           {
00748             VertexInternals& interns = model.vertexInternals(v, tag_t());
00749             Vec& vars = model.values(v, tag_t());
00750             const Vec& derivs = model.derivatives(v, tag_t());
00751             vars -= dt * (1.0 - AEulerResDt) * derivs;
00752             interns.pDerivs = interns.ppDerivs;
00753           }
00754           dt *= AEulerResDt;
00755           if(PrintStats >= 1)
00756             cout << "Euler restart Err:" << err << " Timestep:" << dt << endl;
00757         }
00758         else if(err > AEulerHighTol) // Over high water, reduce step
00759           dt -= dt * AEulerIncDt;
00760         else if(err < AEulerLowTol)    // Under high water, increase step
00761           dt += dt * AEulerIncDt;
00762 
00763         // Clip to max/min
00764         dt = min(MaxDt, max(MinDt, dt));
00765       }
00766       step++;
00767     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveAdaptiveRungeKutta ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the adaptative order 4 runge-kutta method.

Definition at line 964 of file solver.h.

References solver::Solver< nb_vars, identifier >::ARungeHighTol, solver::Solver< nb_vars, identifier >::ARungeIncDt, solver::Solver< nb_vars, identifier >::ARungeLowTol, solver::Solver< nb_vars, identifier >::ARungeResDt, solver::Solver< nb_vars, identifier >::ARungeResTol, solver::Solver< nb_vars, identifier >::ARungeTolType, solver::Solver< nb_vars, identifier >::dt, forall, solver::Solver< nb_vars, identifier >::initialized, solver::MAX_COMPONENT, solver::Solver< nb_vars, identifier >::MaxDt, solver::MEAN_COMPONENT, solver::Solver< nb_vars, identifier >::MinDt, solver::Solver< nb_vars, identifier >::PrintStats, graph::VVGraph< VertexContent, EdgeContent, compact >::size(), and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00965     {
00966       if(!initialized)
00967       {
00968         cerr << "Error, trying to use uninitialized solver" << endl;
00969         return;
00970       }
00971       typedef graph::Vertex<VertexContent> vertex;
00972       double err = 0.0;
00973       for(int rstep = 1; rstep <= 3; rstep++)
00974       {
00975         double ldt = dt;
00976         if(rstep != 1) // 1st step at full dt
00977           ldt *= .5;
00978 
00979         // Save original data values and deltas at start of step - k1
00980         if(rstep != 2) // only compute k1 on 1st and 3rd steps
00981         {
00982           forall(const vertex& v, S)
00983           {
00984             VertexInternals& interns = model.vertexInternals(v, tag_t());
00985             if(rstep == 1) // 1st time through save original vars
00986               interns.pVars = model.values(v, tag_t());
00987             model.updateDerivatives(v, tag_t());
00988             interns.k1 = model.derivatives(v, tag_t());
00989           }
00990         }
00991 
00992         // Find deltas at first trial midpoint - k2
00993         forall(const vertex& v, S)
00994         {
00995           VertexInternals& interns = model.vertexInternals(v, tag_t());
00996           Vec &vars = model.values(v, tag_t());
00997           if(rstep != 3) // Steps 1 & 2 start from beginning of timestep
00998             vars = interns.pVars;
00999           else
01000             vars = interns.mVars;
01001           vars += ldt * .5 * interns.k1;
01002         }
01003         forall(const vertex& v, S)
01004         {
01005           model.updateDerivatives(v, tag_t());
01006           VertexInternals& interns = model.vertexInternals(v, tag_t());
01007           interns.k2 = model.derivatives(v, tag_t());
01008         }
01009 
01010         // Find deltas at second trial midpoint - k3
01011         forall(const vertex& v, S)
01012         {
01013           VertexInternals& interns = model.vertexInternals(v, tag_t());
01014           Vec &vars = model.values(v, tag_t());
01015           if(rstep != 3) // Steps 1 & 2 start from beginning of timestep
01016             vars = interns.pVars;
01017           else
01018             vars = interns.mVars;
01019           vars += ldt * .5 * interns.k2;
01020         }
01021         forall(const vertex& v, S)
01022         {
01023           model.updateDerivatives(v, tag_t());
01024           VertexInternals& interns = model.vertexInternals(v, tag_t());
01025           interns.k3 = model.derivatives(v, tag_t());
01026         }
01027 
01028         // Find deltas at trial endpoint (based on second midpoint estimate) - k3
01029         forall(const vertex& v, S)
01030         {
01031           VertexInternals& interns = model.vertexInternals(v, tag_t());
01032           Vec &vars = model.values(v, tag_t());
01033           if(rstep != 3) // Steps 1 & 2 start from beginning of timestep
01034             vars = interns.pVars;
01035           else
01036             vars = interns.mVars;
01037           vars += ldt * interns.k3;
01038         }
01039         forall(const vertex& v, S)
01040         {
01041           model.updateDerivatives(v, tag_t());
01042           VertexInternals& interns = model.vertexInternals(v, tag_t());
01043           interns.k4 = model.derivatives(v, tag_t());
01044         }
01045 
01046         // Update concentrations based on Runge-Kutta weighted average
01047         forall(const vertex& v, S)
01048         {
01049           VertexInternals& interns = model.vertexInternals(v, tag_t());
01050           Vec &vars = model.values(v, tag_t());
01051           if(rstep != 3) // Steps 1 & 2 update from beginning of timestep
01052             vars = interns.pVars;
01053           else
01054             vars = interns.mVars;
01055 
01056           vars += ldt * ((interns.k1 + interns.k4)/6.0 + (interns.k2 + interns.k3)/3.0);
01057           if(rstep == 1)
01058           {
01059             interns.fVars = vars;
01060           }
01061           else if(rstep == 2)
01062           {
01063             interns.mVars = vars;
01064           }
01065           else // Calc truncation err
01066           {
01067             double derr = norm(vars - interns.fVars)/norm(interns.fVars);
01068             switch(ARungeTolType)
01069             {
01070               case MEAN_COMPONENT:
01071                 err += derr;
01072                 break;
01073               case MAX_COMPONENT:
01074               default:
01075                 if(derr > err)
01076                   err = derr;
01077             }
01078           }
01079         }
01080       }
01081       if(ARungeTolType == MEAN_COMPONENT)
01082         err /= S.size();
01083 
01084       // Check truncation error (diif of midpoints)
01085       if(step != 0)
01086       {
01087         if(err > ARungeResTol && dt > MinDt) // Backup a step and restart
01088         {
01089           forall(const vertex& v, S)
01090           {
01091             VertexInternals &interns = model.vertexInternals(v, tag_t());
01092             Vec &vars = model.values(v, tag_t());
01093             vars = interns.pVars;
01094           }
01095           dt *= ARungeResDt;
01096           if(PrintStats >= 1)
01097             cout << "Runge-Kutta restart Err:" << err << " Timestep:" << dt << endl;
01098         }
01099         else if(err > ARungeHighTol) // Over high water, reduce step
01100           dt -= dt * ARungeIncDt;
01101         else if(err < ARungeLowTol)    // Under high water, increase step
01102           dt += dt * ARungeIncDt;
01103 
01104         // Clip to max/min
01105         dt = min(MaxDt, max(MinDt, dt));
01106       }
01107       step++;
01108     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveEuler ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the forward euler method.

Definition at line 679 of file solver.h.

References solver::Solver< nb_vars, identifier >::dt, forall, solver::Solver< nb_vars, identifier >::initialized, and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00680     {
00681       if(!initialized)
00682       {
00683         cerr << "Error, trying to use uninitialized solver" << endl;
00684         return;
00685       }
00686       typedef graph::Vertex<VertexContent> vertex;
00687       typedef graph::VVGraph<VertexContent,EdgeContent,compact> vvgraph;
00688       forall(const vertex& v, S)
00689       {
00690         model.updateDerivatives(v, tag_t());
00691       }
00692       forall(const vertex& v, S)
00693       {
00694         Vec& vars = model.values(v, tag_t());
00695         const Vec& derivs = model.derivatives(v, tag_t());
00696         vars += dt * derivs;
00697       }
00698       step++;
00699     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveFixedpoint ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the fixed point method.

Definition at line 773 of file solver.h.

References solver::Solver< nb_vars, identifier >::dt, solver::Solver< nb_vars, identifier >::FixedPointMaxSteps, solver::Solver< nb_vars, identifier >::FixedPointTolType, forall, solver::Solver< nb_vars, identifier >::initialized, solver::MAX_COMPONENT, solver::MEAN_COMPONENT, solver::Solver< nb_vars, identifier >::PrintStats, graph::VVGraph< VertexContent, EdgeContent, compact >::size(), and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00774     {
00775       if(!initialized)
00776       {
00777         cerr << "Error, trying to use uninitialized solver" << endl;
00778         return;
00779       }
00780       typedef graph::Vertex<VertexContent> vertex;
00781       // Find initial deltas
00782       forall(const vertex& v, S)
00783       {
00784         model.updateDerivatives(v, tag_t());
00785       }
00786       forall(const vertex& v, S)
00787       {
00788         VertexInternals& interns = model.vertexInternals(v, tag_t());
00789         // save original vars
00790         interns.pDerivs = model.derivatives(v, tag_t());
00791         Vec& vars = model.values(v, tag_t());
00792         interns.pVars = vars;
00793         // Find first estimate
00794         vars += dt * interns.pDerivs;
00795       }
00796 
00797       // Loop to improve approximation
00798       double fxerr = 0;
00799       int fxsteps = 0;
00800       while(true)
00801       {
00802         fxsteps++;
00803         fxerr = 0;
00804         forall(const vertex& v, S)
00805         {
00806           model.updateDerivatives(v, tag_t());
00807         }
00808 
00809         forall(const vertex& v, S)
00810         {
00811           VertexInternals& interns = model.vertexInternals(v, tag_t());
00812           Vec derivs = model.derivatives(v, tag_t());
00813           Vec& vars = model.values(v, tag_t());
00814           vars = interns.pVars + dt * (derivs + interns.pDerivs)/2.0;
00815           double err = norm(derivs - interns.pDerivs);
00816           switch(FixedPointTolType)
00817           {
00818             case MEAN_COMPONENT:
00819               fxerr += err;
00820               break;
00821             case MAX_COMPONENT:
00822             default:
00823               if(err > fxerr)
00824                 fxerr = err;
00825           }
00826           interns.pDerivs = derivs;
00827         }
00828         if(FixedPointTolType == MEAN_COMPONENT)
00829           fxerr /= S.size();
00830 
00831         if(fxerr < FixedPointTol || fxsteps >= FixedPointMaxSteps)
00832           break;
00833       }
00834       if(PrintStats >= 2)
00835         cout << "Fixed point steps:" << fxsteps << ", Err:" << fxerr << endl;
00836       step++;
00837     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveMidpoint ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the mid point method.

Definition at line 843 of file solver.h.

References solver::Solver< nb_vars, identifier >::dt, forall, solver::Solver< nb_vars, identifier >::initialized, and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00844     {
00845       if(!initialized)
00846       {
00847         cerr << "Error, trying to use uninitialized solver" << endl;
00848         return;
00849       }
00850       typedef graph::Vertex<VertexContent> vertex;
00851       // Save original data values and deltas at start of step - k1
00852       forall( vertex v, S)
00853       {
00854         VertexInternals& interns = model.vertexInternals(v, tag_t());
00855         interns.pVars = model.values(v, tag_t());
00856         model.updateDerivatives(v, tag_t());
00857         interns.k1 = model.derivatives(v, tag_t());
00858       }
00859 
00860       // Find deltas at trial midpoint - k2
00861       forall(const vertex& v, S)
00862       {
00863         VertexInternals& interns = model.vertexInternals(v, tag_t());
00864         Vec &vars = model.values(v, tag_t());
00865         vars += dt * 0.5 * interns.k1;
00866       }
00867 
00868       forall(const vertex& v, S)
00869       {
00870         VertexInternals& interns = model.vertexInternals(v, tag_t());
00871         model.updateDerivatives(v, tag_t());
00872         interns.k2 = model.derivatives(v, tag_t());
00873       }
00874 
00875       // Update concentrations based on midpoint deltas
00876       forall(const vertex& v, S)
00877       {
00878         VertexInternals& interns = model.vertexInternals(v, tag_t());
00879         Vec &vars = model.values(v, tag_t());
00880         vars = interns.pVars + dt * interns.k2;
00881       }
00882       step++;
00883     }

template<size_t nb_vars, typename identifier = default_id_t>
template<typename VertexContent , typename EdgeContent , bool compact, typename Model >
void solver::Solver< nb_vars, identifier >::solveRungeKutta ( graph::VVGraph< VertexContent, EdgeContent, compact > &  S,
Model model 
) [inline]

Invoke the solver, forcing the use of the order 4 runge-kutta method.

Definition at line 889 of file solver.h.

References solver::Solver< nb_vars, identifier >::dt, forall, solver::Solver< nb_vars, identifier >::initialized, and solver::Solver< nb_vars, identifier >::step.

Referenced by solver::Solver< nb_vars, identifier >::operator()().

00890     {
00891       if(!initialized)
00892       {
00893         cerr << "Error, trying to use uninitialized solver" << endl;
00894         return;
00895       }
00896       typedef graph::Vertex<VertexContent> vertex;
00897       // Save original data values and deltas at start of step - k1
00898       forall(const vertex& v, S)
00899       {
00900         VertexInternals& interns = model.vertexInternals(v, tag_t());
00901         interns.pVars = model.values(v, tag_t());
00902         model.updateDerivatives(v, tag_t());
00903         interns.k1 = model.derivatives(v, tag_t());
00904       }
00905 
00906       // Find deltas at first trial midpoint - k2
00907       forall(const vertex& v, S)
00908       {
00909         VertexInternals& interns = model.vertexInternals(v, tag_t());
00910         Vec &vars = model.values(v, tag_t());
00911         vars = interns.pVars + dt * .5 * interns.k1;
00912       }
00913       forall(const vertex& v, S)
00914       {
00915         VertexInternals& interns = model.vertexInternals(v, tag_t());
00916         model.updateDerivatives(v, tag_t());
00917         interns.k2 = model.derivatives(v, tag_t());
00918       }
00919 
00920       // Find deltas at second trial midpoint - k3
00921       forall(const vertex& v, S)
00922       {
00923         VertexInternals& interns = model.vertexInternals(v, tag_t());
00924         Vec &vars = model.values(v, tag_t());
00925         vars = interns.pVars + dt * .5 * interns.k2;
00926       }
00927       forall(const vertex& v, S)
00928       {
00929         VertexInternals& interns = model.vertexInternals(v, tag_t());
00930         model.updateDerivatives(v, tag_t());
00931         interns.k3 = model.derivatives(v, tag_t());
00932       }
00933 
00934       // Find deltas at trial endpoint (based on second midpoint estimate) - k3
00935       forall(const vertex& v, S)
00936       {
00937         VertexInternals& interns = model.vertexInternals(v, tag_t());
00938         Vec &vars = model.values(v, tag_t());
00939         vars = interns.pVars + dt * interns.k3;
00940       }
00941       forall(const vertex& v, S)
00942       {
00943         VertexInternals& interns = model.vertexInternals(v, tag_t());
00944         model.updateDerivatives(v, tag_t());
00945         interns.k4 = model.derivatives(v, tag_t());
00946       }
00947 
00948       // Update concentrations based on Runge-Kutta weighted average
00949       forall(const vertex& v, S)
00950       {
00951         VertexInternals& interns = model.vertexInternals(v, tag_t());
00952         Vec &vars = model.values(v, tag_t());
00953         vars = interns.pVars;
00954         vars += dt * ((interns.k1+interns.k4)/6.0 + (interns.k2 + interns.k3)/3.0);
00955       }
00956       step++;
00957     }


Member Data Documentation

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::AEulerHighTol
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::AEulerIncDt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::AEulerLowTol
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::AEulerResDt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::AEulerResTol
template<size_t nb_vars, typename identifier = default_id_t>
ToleranceType solver::Solver< nb_vars, identifier >::AEulerTolType
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ARungeHighTol
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ARungeIncDt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ARungeLowTol
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ARungeResDt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ARungeResTol
template<size_t nb_vars, typename identifier = default_id_t>
ToleranceType solver::Solver< nb_vars, identifier >::ARungeTolType
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ConjGradMaxSteps

Max steps for conjugate gradient (multiple of N).

Definition at line 521 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::ConjGradTol

Tolerence for conjugate gradient.

Definition at line 517 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
ToleranceType solver::Solver< nb_vars, identifier >::ConjGradTolType
template<size_t nb_vars, typename identifier = default_id_t>
bool solver::Solver< nb_vars, identifier >::ConstNbPartials
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::CRAvgCPU

Weight of current dt in eff average.

Definition at line 497 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::CRIncDt

Increment for timestep based on efficiency (mulitple of current size).

Definition at line 493 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::CRMinCPU

Minimun CPU, below this alway increases timestep.

Definition at line 499 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::CRResDt

Decrement for timestep if unsucc.

Definition at line 495 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveAdaptiveCrankNicholson().

template<size_t nb_vars, typename identifier = default_id_t>
SolvingMethod solver::Solver< nb_vars, identifier >::current_method

Method currently used (i.e. it is set only after initialization).

Definition at line 416 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::operator()().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::dt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::Dx

Delta for numerical diff.

Definition at line 530 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::FindPartials(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::EulerDt

Timestep for Forward Euler solver.

Definition at line 429 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::FixedPointDt

Timestep for FixedPoint iteration solver.

Definition at line 431 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::FixedPointMaxSteps

Max steps for fixed point iteration.

Definition at line 465 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms(), and solver::Solver< nb_vars, identifier >::solveFixedpoint().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::FixedPointTol

Tolerance for fixed point iteration.

Definition at line 467 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
ToleranceType solver::Solver< nb_vars, identifier >::FixedPointTolType
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::InitialDt

Timestep for adaptive solvers.

Definition at line 437 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
bool solver::Solver< nb_vars, identifier >::initialized
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::MaxDt
template<size_t nb_vars, typename identifier = default_id_t>
SolvingMethod solver::Solver< nb_vars, identifier >::method

name Parameters

Method read in the parameter file

Definition at line 414 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::MidPointDt

Timestep for MultiPoint iteration solver.

Definition at line 433 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::MinDt
template<size_t nb_vars, typename identifier = default_id_t>
int solver::Solver< nb_vars, identifier >::NewtMaxSteps
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::NewtTol
template<size_t nb_vars, typename identifier = default_id_t>
ToleranceType solver::Solver< nb_vars, identifier >::NewtTolType
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::pdt
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::peff
template<size_t nb_vars, typename identifier = default_id_t>
bool solver::Solver< nb_vars, identifier >::PrintMatrix
template<size_t nb_vars, typename identifier = default_id_t>
int solver::Solver< nb_vars, identifier >::PrintStats
template<size_t nb_vars, typename identifier = default_id_t>
double solver::Solver< nb_vars, identifier >::RungeKuttaDt

Timestep for Runge-Kutta solver.

Definition at line 435 of file solver.h.

Referenced by solver::Solver< nb_vars, identifier >::initialize(), and solver::Solver< nb_vars, identifier >::readParms().

template<size_t nb_vars, typename identifier = default_id_t>
int solver::Solver< nb_vars, identifier >::step

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri May 31 15:38:13 2013 for VVE by  doxygen 1.6.3