Container class for multiple-domain 1D problems.
Each domain is represented by an instance of Domain1D.
Definition at line 26 of file OneDim.h.
|
| | OneDim ()=default |
| | Default constructor.
|
| |
| | OneDim (vector< shared_ptr< Domain1D > > &domains) |
| | Construct a OneDim container for the domains in the list domains.
|
| |
| void | addDomain (shared_ptr< Domain1D > d) |
| | Add a domain. Domains are added left-to-right.
|
| |
| shared_ptr< SystemJacobian > | getJacobian () |
| |
| double | weightedNorm (const double *step) const override |
| | Compute the weighted norm of a step vector.
|
| |
| MultiJac & | jacobian () |
| | Return a reference to the Jacobian evaluator of an OneDim object.
|
| |
| size_t | nDomains () const |
| | Number of domains.
|
| |
| Domain1D & | domain (size_t i) const |
| | Return a reference to domain i.
|
| |
| size_t | domainIndex (const string &name) |
| | Get the index of the domain named name.
|
| |
| void | checkDomainIndex (size_t n) const |
| | Check that the specified domain index is in range.
|
| |
| void | checkDomainArraySize (size_t nn) const |
| | Check that an array size is at least nDomains().
|
| |
| size_t | start (size_t i) const |
| | The index of the start of domain i in the solution vector.
|
| |
| Domain1D * | left () |
| | Pointer to left-most domain (first added).
|
| |
| Domain1D * | right () |
| | Pointer to right-most domain (last added).
|
| |
| size_t | nVars (size_t jg) |
| | Number of solution components at global point jg.
|
| |
| size_t | loc (size_t jg) |
| | Location in the solution vector of the first component of global point jg.
|
| |
| std::tuple< string, size_t, string > | component (size_t i) const |
| | Return the domain, local point index, and component name for the i-th component of the global solution vector.
|
| |
| string | componentName (size_t i) const override |
| | Get the name of the i-th component of the state vector.
|
| |
| pair< string, string > | componentTableHeader () const override |
| | Get header lines describing the column names included in a component label.
|
| |
| string | componentTableLabel (size_t i) const override |
| | Get elements of the component name, aligned with the column headings given by componentTableHeader().
|
| |
| double | upperBound (size_t i) const override |
| | Get the upper bound for global component i in the state vector.
|
| |
| double | lowerBound (size_t i) const override |
| | Get the lower bound for global component i in the state vector.
|
| |
| void | init () |
| | Initialize all domains.
|
| |
| size_t | points () |
| | Total number of points.
|
| |
| void | initTimeInteg (double dt, double *x) override |
| | Prepare for time stepping beginning with solution x and timestep dt.
|
| |
| void | setSteadyMode () override |
| | Prepare to solve the steady-state problem.
|
| |
| void | eval (size_t j, double *x, double *r, double rdt=-1.0, int count=1) |
| | Evaluate the multi-domain residual function.
|
| |
| void | eval (double *x, double *r, double rdt=-1.0, int count=1) override |
| | Evaluate the residual function.
|
| |
| void | evalJacobian (double *x0) override |
| | Evaluates the Jacobian at x0 using finite differences.
|
| |
| Domain1D * | pointDomain (size_t i) |
| | Return a pointer to the domain global point i belongs to.
|
| |
| void | resize () override |
| | Call to set the size of internal data structures after first defining the system or if the problem size changes, for example after grid refinement.
|
| |
| void | resetBadValues (double *x) override |
| | Reset values such as negative species concentrations.
|
| |
| void | writeStats (int printTime=1) |
| | Write statistics about the number of iterations and Jacobians at each grid level.
|
| |
| void | saveStats () |
| | Save statistics on function and Jacobian evaluation, and reset the counters.
|
| |
| void | clearStats () |
| | Clear saved statistics.
|
| |
| const vector< size_t > & | gridSizeStats () |
| | Return total grid size in each call to solve()
|
| |
| const vector< double > & | jacobianTimeStats () |
| | Return CPU time spent evaluating Jacobians in each call to solve()
|
| |
| const vector< double > & | evalTimeStats () |
| | Return CPU time spent on non-Jacobian function evaluations in each call to solve()
|
| |
| const vector< int > & | jacobianCountStats () |
| | Return number of Jacobian evaluations made in each call to solve()
|
| |
| const vector< int > & | evalCountStats () |
| | Return number of non-Jacobian function evaluations made in each call to solve()
|
| |
| const vector< int > & | timeStepStats () |
| | Return number of time steps taken in each call to solve()
|
| |
|
| SteadyStateSystem (const SteadyStateSystem &)=delete |
| |
|
SteadyStateSystem & | operator= (const SteadyStateSystem &)=delete |
| |
| virtual void | eval (double *x, double *r, double rdt=-1.0, int count=1)=0 |
| | Evaluate the residual function.
|
| |
| virtual void | evalJacobian (double *x0)=0 |
| | Evaluates the Jacobian at x0 using finite differences.
|
| |
| virtual double | weightedNorm (const double *step) const =0 |
| | Compute the weighted norm of step.
|
| |
| int | solve (double *x0, double *x1, int loglevel) |
| | Solve \( F(x) = 0 \), where \( F(x) \) is the residual function.
|
| |
| void | setInitialGuess (const double *x) |
| | Set the initial guess. Should be called before solve().
|
| |
| void | solve (int loglevel=0) |
| | Solve the steady-state problem, taking internal timesteps as necessary until the Newton solver can converge for the steady problem.
|
| |
| void | getState (double *x) const |
| | Get the converged steady-state solution after calling solve().
|
| |
| double | ssnorm (double *x, double *r) |
| | Steady-state max norm (infinity norm) of the residual evaluated using solution x.
|
| |
| size_t | size () const |
| | Total solution vector length;.
|
| |
| virtual void | resize () |
| | Call to set the size of internal data structures after first defining the system or if the problem size changes, for example after grid refinement.
|
| |
| size_t | bandwidth () const |
| | Jacobian bandwidth.
|
| |
| virtual string | componentName (size_t i) const |
| | Get the name of the i-th component of the state vector.
|
| |
| virtual pair< string, string > | componentTableHeader () const |
| | Get header lines describing the column names included in a component label.
|
| |
| virtual string | componentTableLabel (size_t i) const |
| | Get elements of the component name, aligned with the column headings given by componentTableHeader().
|
| |
| virtual double | upperBound (size_t i) const =0 |
| | Get the upper bound for global component i in the state vector.
|
| |
| virtual double | lowerBound (size_t i) const =0 |
| | Get the lower bound for global component i in the state vector.
|
| |
| MultiNewton & | newton () |
| | Return a reference to the Newton iterator.
|
| |
| void | setLinearSolver (shared_ptr< SystemJacobian > solver) |
| | Set the linear solver used to hold the Jacobian matrix and solve linear systems as part of each Newton iteration.
|
| |
| shared_ptr< SystemJacobian > | linearSolver () const |
| | Get the the linear solver being used to hold the Jacobian matrix and solve linear systems as part of each Newton iteration.
|
| |
| double | rdt () const |
| | Reciprocal of the time step.
|
| |
| bool | transient () const |
| | True if transient mode.
|
| |
| bool | steady () const |
| | True if steady mode.
|
| |
| virtual void | initTimeInteg (double dt, double *x) |
| | Prepare for time stepping beginning with solution x and timestep dt.
|
| |
| virtual void | setSteadyMode () |
| | Prepare to solve the steady-state problem.
|
| |
| vector< int > & | transientMask () |
| | Access the vector indicating which equations contain a transient term.
|
| |
| double | timeStep (int nsteps, double dt, double *x, double *r, int loglevel) |
| | Take time steps using Backward Euler.
|
| |
| virtual void | resetBadValues (double *x) |
| | Reset values such as negative species concentrations.
|
| |
| void | setJacAge (int ss_age, int ts_age=-1) |
| | Set the maximum number of steps that can be taken using the same Jacobian before it must be re-evaluated.
|
| |
| void | setInterrupt (Func1 *interrupt) |
| | Set a function that will be called every time eval is called.
|
| |
| void | setTimeStepCallback (Func1 *callback) |
| | Set a function that will be called after each successful timestep.
|
| |
| void | setJacobianPerturbation (double relative, double absolute, double threshold) |
| | Configure perturbations used to evaluate finite difference Jacobian.
|
| |
| virtual void | writeDebugInfo (const string &header_suffix, const string &message, int loglevel, int attempt_counter) |
| | Write solver debugging based on the specified log level.
|
| |
| virtual void | clearDebugFile () |
| | Delete debug output file that may be created by writeDebugInfo() when solving with high loglevel.
|
| |
| void | setTimeStep (double stepsize, size_t n, const int *tsteps) |
| | Set the number of time steps to try when the steady Newton solver is unsuccessful.
|
| |
| void | setMinTimeStep (double tmin) |
| | Set the minimum time step allowed during time stepping.
|
| |
| void | setMaxTimeStep (double tmax) |
| | Set the maximum time step allowed during time stepping.
|
| |
| void | setTimeStepFactor (double tfactor) |
| | Sets a factor by which the time step is reduced if the time stepping fails.
|
| |
| void | setMaxTimeStepCount (int nmax) |
| | Set the maximum number of timeteps allowed before successful steady-state solve.
|
| |
| int | maxTimeStepCount () const |
| | Get the maximum number of timeteps allowed before successful steady-state solve.
|
| |
|
| vector< shared_ptr< Domain1D > > | m_dom |
| | All domains comprising the system.
|
| |
| vector< shared_ptr< Domain1D > > | m_connect |
| | All connector and boundary domains.
|
| |
| vector< shared_ptr< Domain1D > > | m_bulk |
| | All bulk/flow domains.
|
| |
| bool | m_init = false |
| | Indicates whether one-time initialization for each domain has been completed.
|
| |
| vector< size_t > | m_nvars |
| | Number of variables at each point, across all domains.
|
| |
| vector< size_t > | m_loc |
| | Location in the state vector of the first component of each point, across all domains.
|
| |
| vector< std::tuple< size_t, size_t, size_t > > | m_componentInfo |
| | Domain, grid point, and component indices for each element of the global state vector.
|
| |
| size_t | m_pts = 0 |
| | Total number of points.
|
| |
| vector< int > | m_steps = { 10 } |
| | Array of number of steps to take after each unsuccessful steady-state solve before re-attempting the steady-state solution.
|
| |
| double | m_tstep = 1.0e-5 |
| | Initial timestep.
|
| |
| double | m_tmin = 1e-16 |
| | Minimum timestep size.
|
| |
| double | m_tmax = 1e+08 |
| | Maximum timestep size.
|
| |
| double | m_tfactor = 0.5 |
| | Factor time step is multiplied by if time stepping fails ( < 1 )
|
| |
| shared_ptr< vector< double > > | m_state |
| | Solution vector.
|
| |
| vector< double > | m_xnew |
| | Work array used to hold the residual or the new solution.
|
| |
| vector< double > | m_xlast_ts |
| | State vector after the last successful set of time steps.
|
| |
| unique_ptr< MultiNewton > | m_newt |
| | Newton iterator.
|
| |
| double | m_rdt = 0.0 |
| | Reciprocal of time step.
|
| |
| shared_ptr< SystemJacobian > | m_jac |
| | Jacobian evaluator.
|
| |
| bool | m_jac_ok = false |
| | If true, Jacobian is current.
|
| |
| size_t | m_bw = 0 |
| | Jacobian bandwidth.
|
| |
| size_t | m_size = 0 |
| | Solution vector size
|
| |
| vector< double > | m_work1 |
| | Work arrays used during Jacobian evaluation.
|
| |
| vector< double > | m_work2 |
| |
| vector< int > | m_mask |
| | Transient mask.
|
| |
| int | m_ss_jac_age = 20 |
| | Maximum age of the Jacobian in steady-state mode.
|
| |
| int | m_ts_jac_age = 20 |
| | Maximum age of the Jacobian in time-stepping mode.
|
| |
| int | m_attempt_counter = 0 |
| | Counter used to manage the number of states stored in the debug log file generated by writeDebugInfo()
|
| |
| int | m_max_history = 10 |
| | Constant that determines the maximum number of states stored in the debug log file generated by writeDebugInfo()
|
| |
| Func1 * | m_interrupt = nullptr |
| | Function called at the start of every call to eval.
|
| |
| Func1 * | m_time_step_callback = nullptr |
| | User-supplied function called after each successful timestep.
|
| |
| int | m_nsteps = 0 |
| | Number of time steps taken in the current call to solve()
|
| |
| int | m_nsteps_max = 500 |
| | Maximum number of timesteps allowed per call to solve()
|
| |
| double | m_jacobianThreshold = 0.0 |
| | Threshold for ignoring small elements in Jacobian.
|
| |
| double | m_jacobianRelPerturb = 1e-5 |
| | Relative perturbation of each component in finite difference Jacobian.
|
| |
| double | m_jacobianAbsPerturb = 1e-10 |
| | Absolute perturbation of each component in finite difference Jacobian.
|
| |
Public Member Functions inherited from SteadyStateSystem
1.9.7