///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// More...
#include <elastic_problems.h>
Public Member Functions  
SolidICProblem ()  
Constructor. Initialise pointer to IC object to NULL. Create a dummy mesh that can be deleted when static problem finally goes out of scope at end of program execution. More...  
SolidICProblem (const SolidICProblem &)=delete  
Broken copy constructor. More...  
void  operator= (const SolidICProblem &)=delete 
Broken assignment operator. More...  
void  actions_after_newton_solve () 
Update after solve (empty) More...  
void  actions_before_newton_solve () 
Update the problem specs before solve. (empty) More...  
void  set_static_initial_condition (Problem *problem_pt, Mesh *mesh_pt, SolidInitialCondition *ic_pt, const double &time) 
Force the elastic structure that is discretised on the specified mesh to deform in the shape of the initial condition object (evaluated at the time specified) More...  
void  set_static_initial_condition (Problem *problem_pt, Mesh *mesh_pt, SolidInitialCondition *ic_pt) 
Force the elastic structure that is discretised on the specified mesh to deform in the shape of the initial condition object (wrapper) More...  
template<class TIMESTEPPER >  
void  set_newmark_initial_condition_directly (Problem *problem_pt, Mesh *mesh_pt, TIMESTEPPER *timestepper_pt, SolidInitialCondition *ic_pt, const double &dt) 
Setup initial condition for timeintegration with Newmark's method. History values are assigned to that the velocity and accelerations determined by the Newmark scheme are exact at the initial time. More...  
template<class TIMESTEPPER >  
void  set_newmark_initial_condition_consistently (Problem *problem_pt, Mesh *mesh_pt, TIMESTEPPER *timestepper_pt, SolidInitialCondition *ic_pt, const double &dt, SolidFiniteElement::MultiplierFctPt multiplier_fct_pt=0) 
Setup initial condition for timeintegration with Newmark's method. Past displacements and velocities are assigned directly (consistent with the idea that a second order ODE can take ICs up to 1st order, while the history value for the previous acceleration is determined by the condition that the weak equation is satisfied at the initial time.) The multiplier function needs to specify the factor that multiplies the inertia terms – typically this is a constant, given by the ratio of the problem's intrinsic timescale to the time used to nondimensionalise the equations. If the function (pointer) is not specified the multiplier is assumed to be equal to 1.0 – appropriate for a nondimensionalisation based on the problem's intrinsic timescale. More...  
double &  max_residual_after_consistent_newton_ic () 
Max. tolerated residual after application of consistent Newmark IC. Used to check if we have specified the correct timescale ratio (nondim density). More...  
Public Member Functions inherited from oomph::Problem  
virtual void  debug_hook_fct (const unsigned &i) 
Hook for debugging. Can be overloaded in driver code; argument allows identification of where we're coming from. More...  
void  set_analytic_dparameter (double *const ¶meter_pt) 
Function to turn on analytic calculation of the parameter derivatives in continuation and bifurcation detection problems. More...  
void  unset_analytic_dparameter (double *const ¶meter_pt) 
Function to turn off analytic calculation of the parameter derivatives in continuation and bifurcation detection problems. More...  
bool  is_dparameter_calculated_analytically (double *const ¶meter_pt) 
Function to determine whether the parameter derivatives are calculated analytically. More...  
void  set_analytic_hessian_products () 
Function to turn on analytic calculation of the parameter derivatives in continuation and bifurcation detection problems. More...  
void  unset_analytic_hessian_products () 
Function to turn off analytic calculation of the parameter derivatives in continuation and bifurcation detection problems. More...  
bool  are_hessian_products_calculated_analytically () 
Function to determine whether the hessian products are calculated analytically. More...  
void  set_pinned_values_to_zero () 
Set all pinned values to zero. Used to set boundary conditions to be homogeneous in the copy of the problem used in adaptive bifurcation tracking (ALH: TEMPORARY HACK, WILL BE FIXED) More...  
bool  distributed () const 
If we have MPI return the "problem has been distributed" flag, otherwise it can't be distributed so return false. More...  
Distributed_problem_matrix_distribution &  distributed_problem_matrix_distribution () 
accesss function to the distributed matrix distribution method 1  Automatic  the Problem distribution is employed, unless any processor has number of rows equal to 110% of N/P, in which case uniform distribution is employed. 2  Problem  the jacobian on processor p only contains rows that correspond to equations that are on this processor. (minimises communication) 3  Uniform  each processor holds as close to N/P matrix rows as possible. (very well load balanced) More...  
void  enable_doc_imbalance_in_parallel_assembly () 
Enable doc of load imbalance in parallel assembly of distributed problem. More...  
void  disable_doc_imbalance_in_parallel_assembly () 
Disable doc of load imbalance in parallel assembly of distributed problem. More...  
Vector< double >  elemental_assembly_time () 
Return vector of mostrecent elemental assembly times (used for load balancing). Zero sized if no Jacobian has been computed since last reassignment of equation numbers. More...  
void  clear_elemental_assembly_time () 
Clear storage of mostrecent elemental assembly times (used for load balancing). Next load balancing operation will be based on the number of elements associated with a tree root. More...  
void  enable_problem_distributed () 
Enable problem distributed. More...  
void  disable_problem_distributed () 
Disable problem distributed. More...  
void  set_default_first_and_last_element_for_assembly () 
Set default first and last elements for parallel assembly of nondistributed problem. More...  
void  set_first_and_last_element_for_assembly (Vector< unsigned > &first_el_for_assembly, Vector< unsigned > &last_el_for_assembly) 
Manually set first and last elements for parallel assembly of nondistributed problem. More...  
void  get_first_and_last_element_for_assembly (Vector< unsigned > &first_el_for_assembly, Vector< unsigned > &last_el_for_assembly) const 
Get first and last elements for parallel assembly of nondistributed problem. More...  
virtual void  actions_before_adapt () 
Actions that are to be performed before a mesh adaptation. These might include removing any additional elements, such as traction boundary elements before the adaptation. More...  
virtual void  actions_after_adapt () 
Actions that are to be performed after a mesh adaptation. More...  
OomphCommunicator *  communicator_pt () 
access function to the oomphlib communicator More...  
const OomphCommunicator *  communicator_pt () const 
access function to the oomphlib communicator, const version More...  
Problem ()  
Constructor: Allocate space for one time stepper and set all pointers to NULL and set defaults for all parameters. More...  
Problem (const Problem &dummy)=delete  
Broken copy constructor. More...  
void  operator= (const Problem &)=delete 
Broken assignment operator. More...  
virtual  ~Problem () 
Virtual destructor to clean up memory. More...  
Mesh *&  mesh_pt () 
Return a pointer to the global mesh. More...  
Mesh *const &  mesh_pt () const 
Return a pointer to the global mesh (const version) More...  
Mesh *&  mesh_pt (const unsigned &imesh) 
Return a pointer to the ith submesh. If there are no submeshes, the 0th submesh is the global mesh itself. More...  
Mesh *const &  mesh_pt (const unsigned &imesh) const 
Return a pointer to the ith submesh (const version) More...  
unsigned  nsub_mesh () const 
Return number of submeshes. More...  
unsigned  add_sub_mesh (Mesh *const &mesh_pt) 
Add a submesh to the problem and return its number, i, by which it can be accessed via mesh_pt(i). More...  
void  flush_sub_meshes () 
Flush the problem's collection of submeshes. Must be followed by call to rebuild_global_mesh(). More...  
void  build_global_mesh () 
Build the global mesh by combining the all the submeshes. Note: The nodes boundary information refers to the boundary numbers within the submesh! More...  
void  rebuild_global_mesh () 
If one of the submeshes has changed (e.g. by mesh adaptation) we need to update the global mesh. Note: The nodes boundary information refers to the boundary numbers within the submesh! More...  
virtual void  build_mesh () 
Function to build the Problem's base mesh; this must be supplied by the user if they wish to use the load_balance() functionality, which is only available to problems that have already been distributed. If the problem has multiple meshes, each mesh must be built, added as as a submesh, and a call to build_global_mesh() must be made in this function. On return from this function all meshes must have been refined to the same level that they were in the when Problem::distribute() was first called. More...  
void  load_balance () 
Balance the load of a (possibly nonuniformly refined) problem that has already been distributed, by redistributing elements over processors. More...  
void  load_balance (const bool &report_stats) 
Balance the load of a (possibly nonuniformly refined) problem that has already been distributed, by redistributing elements over processors. Produce explicit stats of load balancing process if boolean, report_stats, is set to true. More...  
void  load_balance (DocInfo &doc_info, const bool &report_stats) 
Balance the load of a (possibly nonuniformly refined) problem that has already been distributed, by redistributing elements over processors. Produce explicit stats of load balancing process if boolean, report_stats, is set to true. More...  
void  load_balance (DocInfo &doc_info, const bool &report_stats, const Vector< unsigned > &input_target_domain_for_local_non_halo_element) 
Balance the load of a (possibly nonuniformly refined) problem that has already been distributed, by redistributing elements over processors. Produce explicit stats of load balancing process if boolean, report_stats, is set to true and doc various bits of data (mainly for debugging) in directory specified by DocInfo object. If final input vector is nonzerosized it provides an imposed partitioning. More...  
void  set_default_partition_in_load_balance () 
Set the use of the default partition in the load balance. More...  
void  unset_default_partition_in_load_balance () 
Do not use the default partition in the load balance. More...  
void  refine_distributed_base_mesh (Vector< Vector< Vector< unsigned >>> &to_be_refined_on_each_root, const unsigned &max_level_overall) 
Load balance helper routine: refine each new base (sub)mesh based upon the elements to be refined within each tree at each root on the current processor. More...  
LinearSolver *&  linear_solver_pt () 
Return a pointer to the linear solver object. More...  
LinearSolver *const &  linear_solver_pt () const 
Return a pointer to the linear solver object (const version) More...  
LinearSolver *&  mass_matrix_solver_for_explicit_timestepper_pt () 
Return a pointer to the linear solver object used for explicit time stepping. More...  
LinearSolver *  mass_matrix_solver_for_explicit_timestepper_pt () const 
Return a pointer to the linear solver object used for explicit time stepping (const version). More...  
EigenSolver *&  eigen_solver_pt () 
Return a pointer to the eigen solver object. More...  
EigenSolver *const &  eigen_solver_pt () const 
Return a pointer to the eigen solver object (const version) More...  
Time *&  time_pt () 
Return a pointer to the global time object. More...  
Time *  time_pt () const 
Return a pointer to the global time object (const version). More...  
double &  time () 
Return the current value of continuous time. More...  
double  time () const 
Return the current value of continuous time (const version) More...  
TimeStepper *&  time_stepper_pt () 
Access function for the pointer to the first (presumably only) timestepper. More...  
const TimeStepper *  time_stepper_pt () const 
Access function for the pointer to the first (presumably only) timestepper. More...  
TimeStepper *&  time_stepper_pt (const unsigned &i) 
Return a pointer to the ith timestepper. More...  
ExplicitTimeStepper *&  explicit_time_stepper_pt () 
Return a pointer to the explicit timestepper. More...  
unsigned long  set_timestepper_for_all_data (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data=false) 
Set all problem data to have the same timestepper (timestepper_pt) Return the new number of dofs in the problem. More...  
virtual void  shift_time_values () 
Shift all values along to prepare for next timestep. More...  
AssemblyHandler *&  assembly_handler_pt () 
Return a pointer to the assembly handler object. More...  
AssemblyHandler *const &  assembly_handler_pt () const 
Return a pointer to the assembly handler object (const version) More...  
double &  minimum_dt () 
Access function to min timestep in adaptive timestepping. More...  
double &  maximum_dt () 
Access function to max timestep in adaptive timestepping. More...  
unsigned &  max_newton_iterations () 
Access function to max Newton iterations before giving up. More...  
void  problem_is_nonlinear (const bool &prob_lin) 
Access function to Problem_is_nonlinear. More...  
double &  max_residuals () 
Access function to max residuals in Newton iterations before giving up. More...  
bool &  time_adaptive_newton_crash_on_solve_fail () 
Access function for Time_adaptive_newton_crash_on_solve_fail. More...  
double &  newton_solver_tolerance () 
Access function to tolererance of the Newton solver, i.e. the maximum value of the residuals that will be accepted. More...  
void  add_time_stepper_pt (TimeStepper *const &time_stepper_pt) 
Add a timestepper to the problem. The function will automatically create or resize the Time object so that it contains the appropriate number of levels of storage. More...  
void  set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt) 
Set the explicit timestepper for the problem. The function will automatically create or resize the Time object so that it contains the appropriate number of levels of storage. More...  
void  initialise_dt (const double &dt) 
Set all timesteps to the same value, dt, and assign weights for all timesteppers in the problem. More...  
void  initialise_dt (const Vector< double > &dt) 
Set the value of the timesteps to be equal to the values passed in a vector and assign weights for all timesteppers in the problem. More...  
Data *&  global_data_pt (const unsigned &i) 
Return a pointer to the the ith global data object. More...  
void  add_global_data (Data *const &global_data_pt) 
Add Data to the Problem's global data – the Problem will perform equation numbering etc. for such Data. More...  
void  flush_global_data () 
Flush the Problem's global data – resizes container to zero. Data objects are not deleted! More...  
void  create_new_linear_algebra_distribution (LinearAlgebraDistribution *&dist_pt) 
Get new linear algebra distribution (you're in charge of deleting it!) More...  
LinearAlgebraDistribution *const &  dof_distribution_pt () const 
Return the pointer to the dof distribution (readonly) More...  
unsigned long  ndof () const 
Return the number of dofs. More...  
unsigned  ntime_stepper () const 
Return the number of time steppers. More...  
unsigned  nglobal_data () const 
Return the number of global data values. More...  
unsigned  self_test () 
Selftest: Check meshes and global data. Return 0 for OK. More...  
void  enable_store_local_dof_pt_in_elements () 
Insist that local dof pointers are set up in each element when equation numbering takes place. More...  
void  disable_store_local_dof_pt_in_elements () 
Insist that local dof pointers are NOT set up in each element when equation numbering takes place (the default) More...  
unsigned long  assign_eqn_numbers (const bool &assign_local_eqn_numbers=true) 
Assign all equation numbers for problem: Deals with global data (= data that isn't attached to any elements) and then does the equation numbering for the elements. Virtual so it can be overloaded in MPI problems. Bool argument can be set to false to ignore assigning local equation numbers (found to be necessary in the parallel implementation of locate_zeta between multiple meshes). More...  
void  describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const 
Function to describe the dofs in terms of the global equation number, i.e. what type of value (nodal value of a Node; value in a Data object; value of internal Data in an element; etc) is the unknown with a certain global equation number. Output stream defaults to oomph_info. More...  
void  enable_discontinuous_formulation () 
Indicate that the problem involves discontinuous elements This allows for a more efficiently assembly and inversion of the mass matrix. More...  
void  disable_discontinuous_formulation () 
Disable the use of a discontinuouselement formulation. Note that the methods will all still work even if the elements are discontinuous, we will just be assembling a larger system matrix than necessary. More...  
void  get_dofs (DoubleVector &dofs) const 
Return the vector of dofs, i.e. a vector containing the current values of all unknowns. More...  
void  get_dofs (const unsigned &t, DoubleVector &dofs) const 
Return vector of the t'th history value of all dofs. More...  
void  set_dofs (const DoubleVector &dofs) 
Set the values of the dofs. More...  
void  set_dofs (const unsigned &t, DoubleVector &dofs) 
Set the history values of the dofs. More...  
void  set_dofs (const unsigned &t, Vector< double * > &dof_pt) 
Set history values of dofs from the type of vector stored in problem::Dof_pt. More...  
void  add_to_dofs (const double &lambda, const DoubleVector &increment_dofs) 
Add lambda x incremenet_dofs[l] to the lth dof. More...  
double *  global_dof_pt (const unsigned &i) 
Return a pointer to the dof, indexed by global equation number which may be haloed or stored locally. If it is haloed, a local copy must have been requested on this processor in the Halo_scheme_pt. More...  
double &  dof (const unsigned &i) 
ith dof in the problem More...  
double  dof (const unsigned &i) const 
ith dof in the problem (const version) More...  
double *&  dof_pt (const unsigned &i) 
Pointer to ith dof in the problem. More...  
double *  dof_pt (const unsigned &i) const 
Pointer to ith dof in the problem (const version) More...  
virtual void  get_inverse_mass_matrix_times_residuals (DoubleVector &Mres) 
Return the residual vector multiplied by the inverse mass matrix Virtual so that it can be overloaded for mpi problems. More...  
virtual void  get_dvaluesdt (DoubleVector &f) 
Get the time derivative of all values (using get_inverse_mass_matrix_times_residuals(..) with all time steppers set to steady) e.g. for use in explicit time steps. The approach used is slighty hacky, beware if you have a residual which is nonlinear or implicit in the derivative or if you have overloaded get_jacobian(...). More...  
virtual void  get_residuals (DoubleVector &residuals) 
Return the fullyassembled residuals Vector for the problem: Virtual so it can be overloaded in for mpi problems. More...  
virtual void  get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian) 
Return the fullyassembled Jacobian and residuals for the problem Interface for the case when the Jacobian matrix is dense. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices, we can bypass the default assembly procedure for the Jacobian and the residual vector. More...  
virtual void  get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian) 
Return the fullyassembled Jacobian and residuals for the problem. Interface for the case when the Jacobian is in rowcompressed storage format. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices), we can bypass the default assembly procedure for the Jacobian and the residual vector. More...  
virtual void  get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian) 
Return the fullyassembled Jacobian and residuals for the problem. Interface for the case when the Jacobian is in columncompressed storage format. This is virtual so, if we feel like it (e.g. for testing iterative solvers with specific test matrices), we can bypass the default assembly procedure for the Jacobian and the residual vector. More...  
virtual void  get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian) 
Dummy virtual function that must be overloaded by the problem to specify which matrices should be summed to give the final Jacobian. More...  
void  get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian) 
Return the fullyassembled Jacobian and residuals, generated by finite differences. More...  
void  get_derivative_wrt_global_parameter (double *const ¶meter_pt, DoubleVector &result) 
Get the derivative of the entire residuals vector wrt a global parameter, used in continuation problems. More...  
void  get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product) 
Return the product of the global hessian (derivative of Jacobian matrix with respect to all variables) with an eigenvector, Y, and any number of other specified vectors C (d(J_{ij})/d u_{k}) Y_{j} C_{k}. This function is used in assembling and solving the augmented systems associated with bifurcation tracking. The default implementation is to use finite differences at the global level. More...  
void  solve_eigenproblem_legacy (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true) 
Get derivative of an element in the problem wrt a global parameter, used in continuation problems. More...  
void  solve_eigenproblem_legacy (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true) 
Solve an eigenproblem as assembled by the Problem's constituent elements. Calculate (at least) n_eval eigenvalues. The boolean flag (default true) specifies whether the steady jacobian should be assembled. If the flag is false then the weighted massmatrix terms from the timestepper will be included in the jacobian — this is almost certainly never wanted. Legacy version. More...  
void  solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &alpha, Vector< double > &beta, Vector< DoubleVector > &eigenvector_real, Vector< DoubleVector > &eigenvector_imag, const bool &steady=true) 
Solve an eigenproblem as assembled by the Problem's constituent elements. Calculate (at least) n_eval eigenvalues and return the corresponding eigenvectors. The boolean flag (default true) specifies whether the steady jacobian should be assembled. If the flag is false then the weighted massmatrix terms from the timestepper will be included in the jacobian — this is almost certainly never wanted. The eigenvalues and eigenvectors are, in general, complex. Eigenvalues may be infinite and are therefore returned as where is complex while is real. The actual eigenvalues may then be computed by doing the division, checking for zero betas to avoid NaNs. There's a convenience wrapper to this function that simply computes these eigenvalues regardless. That version may die in NaN checking is enabled (via the fenv.h header and the associated feenable function). More...  
void  solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector_real, Vector< DoubleVector > &eigenvector_imag, const bool &steady=true) 
Solve an eigenproblem as assembled by the Problem's constituent elements. Calculate (at least) n_eval eigenvalues and return the corresponding eigenvectors. The boolean flag (default true) specifies whether the steady jacobian should be assembled. If the flag is false then the weighted massmatrix terms from the timestepper will be included in the jacobian — this is almost certainly never wanted. Note that the eigenvalues and eigenvectors are, in general, complex and the eigenvalues may be infinite. In this case it's safer to use the other version of this function which returns the eigenvalues in terms of a fractional representation. More...  
void  solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &make_timesteppers_steady=true) 
Solve an eigenproblem as assembled by the Problem's constituent elements but only return the eigenvalues, not the eigenvectors. At least n_eval eigenvalues are computed. The boolean flag (default true) is used to specify whether the weighted massmatrix terms from the timestepping scheme should be included in the jacobian — this is almost certainly never wanted. Note that the eigenvalues may be infinite. In this case it's safer to use the other version of this function which returns the eigenvalues in terms of a fractional representation. More...  
void  solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &alpha, Vector< double > &beta, const bool &steady=true) 
Solve an eigenproblem as assembled by the Problem's constituent elements but only return the eigenvalues, not the eigenvectors. At least n_eval eigenvalues are computed. The boolean flag (default true) is used to specify whether the weighted massmatrix terms from the timestepping scheme should be included in the jacobian — this is almost certainly never wanted. Note that the eigenvalues may be infinite and are therefore returned as where is complex while is real. The actual eigenvalues may then be computed by doing the division, checking for zero betas to avoid NaNs. More...  
void  solve_adjoint_eigenproblem_legacy (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &make_timesteppers_steady=true) 
Solve an adjoint eigenvalue problem using the same procedure as solve_eigenproblem. See the documentation on that function for more details. Note: this is a legacy version of this function that stores re & imag parts of eigenvectors in some solverspecific collection of real vectors. More...  
void  solve_adjoint_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector_real, Vector< DoubleVector > &eigenvector_imag, const bool &steady=true) 
Solve an adjoint eigenvalue problem using the same procedure as solve_eigenproblem. See the documentation on that function for more details. More...  
void  solve_adjoint_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true) 
Solve an adjoint eigenvalue problem using the same procedure as solve_eigenproblem but only return the eigenvalues, not the eigenvectors. At least n_eval eigenvalues are computed. See the documentation on that function for more details. More...  
virtual void  get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0) 
Get the matrices required by a eigensolver. If the shift parameter is nonzero the second matrix will be shifted. More...  
void  assign_eigenvector_to_dofs (DoubleVector &eigenvector) 
Assign the eigenvector passed to the function to the dofs in the problem so that it can be output by the usual routines. More...  
void  add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector) 
Add the eigenvector passed to the function scaled by the constat epsilon to the dofs in the problem so that it can be output by the usual routines. More...  
void  store_current_dof_values () 
Store the current values of the degrees of freedom. More...  
void  restore_dof_values () 
Restore the stored values of the degrees of freedom. More...  
void  enable_jacobian_reuse () 
Enable recycling of Jacobian in Newton iteration (if the linear solver allows it). Useful for linear problems with constant Jacobians or nonlinear problems where you're willing to risk the tradeoff between faster solve times and degraded Newton convergence rate. More...  
void  disable_jacobian_reuse () 
Disable recycling of Jacobian in Newton iteration. More...  
bool  jacobian_reuse_is_enabled () 
Is recycling of Jacobian in Newton iteration enabled? More...  
bool &  use_predictor_values_as_initial_guess () 
void  newton_solve () 
Use Newton method to solve the problem. More...  
void  enable_globally_convergent_newton_method () 
enable globally convergent Newton method More...  
void  disable_globally_convergent_newton_method () 
disable globally convergent Newton method More...  
void  newton_solve (unsigned const &max_adapt) 
Adaptive Newton solve: up to max_adapt adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes. More...  
void  steady_newton_solve (unsigned const &max_adapt=0) 
Solve a steady problem using adaptive Newton's method, but in the context of an overall unstady problem, perhaps to determine an initial condition. This is achieved by setting the weights in the timesteppers to be zero which has the effect of rendering them steady timesteppers. The optional argument max_adapt specifies the max. number of adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes. More...  
void  copy (Problem *orig_problem_pt) 
Copy Data values, nodal positions etc from specified problem. Note: This is not a copy constructor. We assume that the current and the "original" problem have both been created by calling the same problem constructor so that all Data objects, time steppers etc. in the two problems are completely independent. This function copies the nodal, internal and global values, and the time parameters from the original problem into "this" one. This functionality is required, e.g. for multigrid computations. More...  
virtual Problem *  make_copy () 
Make and return a pointer to the copy of the problem. A virtual function that must be filled in by the user is they wish to perform adaptive refinement in bifurcation tracking or in multigrid problems. ALH: WILL NOT BE NECESSARY IN BIFURCATION TRACKING IN LONG RUN... More...  
virtual void  read (std::ifstream &restart_file, bool &unsteady_restart) 
Read refinement pattern of all refineable meshes and refine them accordingly, then read all Data and nodal position info from file for restart. Return flag to indicate if the restart was from steady or unsteady solution. More...  
virtual void  read (std::ifstream &restart_file) 
Read refinement pattern of all refineable meshes and refine them accordingly, then read all Data and nodal position info from file for restart. More...  
virtual void  dump (std::ofstream &dump_file) const 
Dump refinement pattern of all refineable meshes and all generic Problem data to file for restart. More...  
void  dump (const std::string &dump_file_name) const 
Dump refinement pattern of all refineable meshes and all generic Problem data to file for restart. More...  
void  get_all_halo_data (std::map< unsigned, double * > &map_of_halo_data) 
Get pointers to all possible halo data indexed by global equation number in a map. More...  
long  synchronise_eqn_numbers (const bool &assign_local_eqn_numbers=true) 
Classify any nonclassified nodes into halo/haloed and synchronise equation numbers. Return the total number of degrees of freedom in the overall problem. More...  
void  synchronise_dofs (const bool &do_halos, const bool &do_external_halos) 
Synchronise the degrees of freedom by overwriting the haloed values with their nonhalo counterparts held on other processors. Bools control if we deal with data associated with external halo/ed elements/nodes or the "normal" halo/ed ones. More...  
void  synchronise_all_dofs () 
Perform all required synchronisation in solvers. More...  
void  check_halo_schemes (DocInfo &doc_info) 
Check the halo/haloed node/element schemes. More...  
void  check_halo_schemes () 
Check the halo/haloed node/element schemes. More...  
Vector< unsigned >  distribute (const Vector< unsigned > &element_partition, DocInfo &doc_info, const bool &report_stats=false) 
Distribute the problem and doc, using the specified partition; returns a vector which details the partitioning. More...  
Vector< unsigned >  distribute (DocInfo &doc_info, const bool &report_stats=false) 
Distribute the problem; returns a vector which details the partitioning. More...  
Vector< unsigned >  distribute (const Vector< unsigned > &element_partition, const bool &report_stats=false) 
Distribute the problem using the specified partition; returns a vector which details the partitioning. More...  
Vector< unsigned >  distribute (const bool &report_stats=false) 
Distribute the problem; returns a vector which details the partitioning. More...  
virtual void  partition_global_mesh (Mesh *&global_mesh_pt, DocInfo &doc_info, Vector< unsigned > &element_domain, const bool &report_stats=false) 
Partition the global mesh, return vector specifying the processor number for each element. Virtual so that it can be overloaded by any user; the default is to use METIS to perform the partitioning (with a bit of cleaning up afterwards to sort out "special cases"). More...  
void  prune_halo_elements_and_nodes (DocInfo &doc_info, const bool &report_stats) 
(Irreversibly) prune halo(ed) elements and nodes, usually after another round of refinement, to get rid of excessively wide halo layers. Note that the current mesh will be now regarded as the base mesh and no unrefinement relative to it will be possible once this function has been called. More...  
void  prune_halo_elements_and_nodes (const bool &report_stats=false) 
(Irreversibly) prune halo(ed) elements and nodes, usually after another round of refinement, to get rid of excessively wide halo layers. Note that the current mesh will be now regarded as the base mesh and no unrefinement relative to it will be possible once this function has been called. More...  
bool  problem_has_been_distributed () 
Access to Problem_has_been_distributed flag. More...  
void  delete_all_external_storage () 
Wrapper function to delete external storage for each submesh of the problem. More...  
virtual void  symmetrise_eigenfunction_for_adaptive_pitchfork_tracking () 
Virtual function that is used to symmetrise the problem so that the current solution exactly satisfies any symmetries within the system. Used when adpativly solving pitchfork detection problems when small asymmetries in the coarse solution can be magnified leading to very inaccurate answers on the fine mesh. This is always problemspecific and must be filled in by the user The default issues a warning. More...  
double *  bifurcation_parameter_pt () const 
Return pointer to the parameter that is used in the bifurcation detection. If we are not tracking a bifurcation then an error will be thrown by the AssemblyHandler. More...  
void  get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction) 
Return the eigenfunction calculated as part of a bifurcation tracking process. If we are not tracking a bifurcation then an error will be thrown by the AssemblyHandler. More...  
void  activate_fold_tracking (double *const ¶meter_pt, const bool &block_solve=true) 
Turn on fold tracking using the augmented system specified in the FoldHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a fold (limit) point at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. If the boolean flag block_solver is true (the default) then a block factorisation is used to solve the augmented system which is both faster and uses less memory. More...  
void  activate_bifurcation_tracking (double *const ¶meter_pt, const DoubleVector &eigenvector, const bool &block_solve=true) 
Activate generic bifurcation tracking for a single (real) eigenvalue where the initial guess for the eigenvector can be specified. More...  
void  activate_bifurcation_tracking (double *const ¶meter_pt, const DoubleVector &eigenvector, const DoubleVector &normalisation, const bool &block_solve=true) 
Activate generic bifurcation tracking for a single (real) eigenvalue where the initial guess for the eigenvector can be specified and the normalisation condition can also be specified. More...  
void  activate_pitchfork_tracking (double *const ¶meter_pt, const DoubleVector &symmetry_vector, const bool &block_solve=true) 
Turn on pitchfork tracking using the augmented system specified in the PitchForkHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a pitchfork bifurcation at a particular value of the variable addressed by parameter_pt. The symmetry that is to be broken must be specified by supplying a symmetry_vector(ndof). The easiest way to determine such a vector is to solve the associated eigenproblem and pass in the eigenvector. This is not always necessary however, if the symmetry is easy to construct. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. If the boolean flag block_solver is true (the default) then a block factorisation is used to solve the augmented system which is both faster and requires less memory. More...  
void  activate_hopf_tracking (double *const ¶meter_pt, const bool &block_solve=true) 
Turn on Hopf bifurcation tracking using the augmented system specified in the HopfHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a Hopf bifuraction at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. More...  
void  activate_hopf_tracking (double *const ¶meter_pt, const double &omega, const DoubleVector &null_real, const DoubleVector &null_imag, const bool &block_solve=true) 
Turn on Hopf bifurcation tracking using the augmented system specified in the HopfHandler class. After a call to this function subsequent calls of the standard solution methods will converge to a Hopf bifuraction at a particular value of the variable addressed by parameter_pt. The system may not converge if the initial guess is sufficiently poor or, alternatively, if finite differencing is used to calculate the jacobian matrix in the elements. This interface allows specification of an inital guess for the frequency and real and imaginary parts of the null vector, such as might be obtained from an eigensolve. More...  
void  deactivate_bifurcation_tracking () 
Deactivate all bifuraction tracking, by reseting the assembly handler to the default. More...  
void  reset_assembly_handler_to_default () 
Reset the system to the standard nonaugemented state. More...  
double  arc_length_step_solve (double *const ¶meter_pt, const double &ds, const unsigned &max_adapt=0) 
Solve a steady problem using arclength continuation, when the parameter that becomes a variable corresponding to the arclength constraint equation is an external double: parameter_pt is a pointer to that double, ds is the desired arc_length and max_adapt is the maximum number of spatial adaptations (default zero, no adaptation). More...  
double  arc_length_step_solve (Data *const &data_pt, const unsigned &data_index, const double &ds, const unsigned &max_adapt=0) 
Solve a steady problem using arclength continuation, when the variable corresponding to the arclength constraint equation is already stored in data used in the problem: data_pt is a pointer to the appropriate data object, data_index is the index of the value that will be traded for the constriant, ds is the desired arc_length and max_adapt is the maximum number of spatial adaptations (default zero, no adaptation). Note that the value must be pinned in order for this formulation to work. More...  
void  reset_arc_length_parameters () 
Reset the "internal" arclength continuation parameters, so as to allow continuation in another parameter. N.B. The parameters that are reset are the "minimum" that are required, others should perhaps be reset, depending upon the application. More...  
int &  sign_of_jacobian () 
Access function for the sign of the global jacobian matrix. This will be set by the linear solver, if possible (direct solver). If not alternative methods must be used to detect bifurcations (solving the associated eigenproblem). More...  
void  explicit_timestep (const double &dt, const bool &shift_values=true) 
Take an explicit timestep of size dt and optionally shift any stored values of the time history. More...  
void  unsteady_newton_solve (const double &dt) 
Advance time by dt and solve by Newton's method. This version always shifts time values. More...  
void  unsteady_newton_solve (const double &dt, const bool &shift_values) 
Advance time by dt and solve the system, using Newton's method. The boolean flag is used to control whether the time values should be shifted. If it is true the current data values will be shifted (copied to the locations where there are stored as previous timesteps) before solution. More...  
void  unsteady_newton_solve (const double &dt, const unsigned &max_adapt, const bool &first, const bool &shift=true) 
Unsteady adaptive Newton solve: up to max_adapt adaptations of all refineable submeshes are performed to achieve the the error targets specified in the refineable submeshes. If first==true, the initial conditions are reassigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly reassigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued. More...  
double  doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const bool &first, const bool &shift=true) 
Unsteady "doubly" adaptive Newton solve: Does temporal adaptation first, i.e. we try to do a timestep with an increment of dt, and adjusting dt until the solution on the given mesh satisfies the temporal error measure with tolerance epsilon. Following this, we do up to max_adapt spatial adaptions (without reexamining the temporal error). If first==true, the initial conditions are reassigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly reassigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued. More...  
double  doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const unsigned &suppress_resolve_after_spatial_adapt_flag, const bool &first, const bool &shift=true) 
Unsteady "doubly" adaptive Newton solve: Does temporal adaptation first, i.e. we try to do a timestep with an increment of dt, and adjusting dt until the solution on the given mesh satisfies the temporal error measure with tolerance epsilon. Following this, we do up to max_adapt spatial adaptions (without reexamining the temporal error). If first==true, the initial conditions are reassigned after the mesh adaptations. Shifting of time can be suppressed by overwriting the default value of shift (true). [Shifting must be done if first_timestep==true because we're constantly reassigning the initial conditions; if first_timestep==true and shift==false shifting is performed anyway and a warning is issued. PseudoBoolean flag suppress_resolve_after_spatial_adapt [0: false; 1: true] does what it says.]. More...  
double  adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon) 
Attempt to advance timestep by dt_desired. If the solution fails the timestep will be halved until convergence is achieved, or the timestep falls below NewtonSolverParameters::Minimum_time_step. The error control parameter epsilon represents the (approximate) desired magnitude of the global error at each timestep. The routine returns a double that is the suggested next timestep and should be passed as dt_desired the next time the routine is called. This version always shifts the time values. More...  
double  adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon, const bool &shift_values) 
Attempt to advance timestep by dt_desired. If the solution fails the timestep will be halved until convergence is achieved, or the timestep falls below NewtonSolverParameters::Minimum_time_step. The error control parameter epsilon represents the (approximate) desired magnitude of the global error at each timestep. The routine returns a double that is the suggested next timestep and should be passed as dt_desired the next time the routine is called. Once again the boolean flag, shift_values, is used to control whether the time values are shifted. More...  
void  assign_initial_values_impulsive () 
Initialise data and nodal positions to simulate impulsive start from initial configuration/solution. More...  
void  assign_initial_values_impulsive (const double &dt) 
Initialise data and nodal positions to simulate an impulsive start and also set the initial and previous values of dt. More...  
void  calculate_predictions () 
Calculate predictions. More...  
void  enable_mass_matrix_reuse () 
Enable recycling of the mass matrix in explicit timestepping schemes. Useful for timestepping on fixed meshes when you want to avoid the linear solve phase. More...  
void  disable_mass_matrix_reuse () 
Turn off recyling of the mass matrix in explicit timestepping schemes. More...  
bool  mass_matrix_reuse_is_enabled () 
Return whether the mass matrix is being reused. More...  
void  refine_uniformly (const Vector< unsigned > &nrefine_for_mesh) 
Refine refineable submeshes, each as many times as specified in the vector and rebuild problem. More...  
void  refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info) 
Refine refineable submeshes, each as many times as specified in the vector and rebuild problem; doc refinement process. More...  
void  refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh) 
Refine refineable submeshes, each as many times as specified in the vector and rebuild problem. Prune after refinements. More...  
void  refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info) 
Refine refineable submeshes, each as many times as specified in the vector and rebuild problem; doc refinement process. More...  
void  refine_uniformly (DocInfo &doc_info) 
Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process. More...  
void  refine_uniformly_and_prune (DocInfo &doc_info) 
Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process. More...  
void  refine_uniformly () 
Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem. More...  
void  refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info) 
Do uniform refinement for submesh i_mesh with documentation. More...  
void  refine_uniformly (const unsigned &i_mesh) 
Do uniform refinement for submesh i_mesh without documentation. More...  
void  p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh) 
prefine prefineable submeshes, each as many times as specified in the vector and rebuild problem More...  
void  p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info) 
prefine prefineable submeshes, each as many times as specified in the vector and rebuild problem; doc refinement process More...  
void  p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh) 
prefine prefineable submeshes, each as many times as specified in the vector and rebuild problem. Prune after refinements More...  
void  p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info) 
prefine prefineable submeshes, each as many times as specified in the vector and rebuild problem; doc refinement process More...  
void  p_refine_uniformly (DocInfo &doc_info) 
prefine (all) prefineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process. More...  
void  p_refine_uniformly_and_prune (DocInfo &doc_info) 
prefine (all) prefineable (sub)mesh(es) uniformly and rebuild problem; doc refinement process. More...  
void  p_refine_uniformly () 
prefine (all) prefineable (sub)mesh(es) uniformly and rebuild problem More...  
void  p_refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info) 
Do uniform prefinement for submesh i_mesh with documentation. More...  
void  p_refine_uniformly (const unsigned &i_mesh) 
Do uniform prefinement for submesh i_mesh without documentation. More...  
void  refine_selected_elements (const Vector< unsigned > &elements_to_be_refined) 
Refine (one and only!) mesh by splitting the elements identified by their numbers relative to the problems' only mesh, then rebuild the problem. More...  
void  refine_selected_elements (const Vector< RefineableElement * > &elements_to_be_refined_pt) 
Refine (one and only!) mesh by splitting the elements identified by their pointers, then rebuild the problem. More...  
void  refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined) 
Refine specified submesh by splitting the elements identified by their numbers relative to the submesh, then rebuild the problem. More...  
void  refine_selected_elements (const unsigned &i_mesh, const Vector< RefineableElement * > &elements_to_be_refined_pt) 
Refine specified submesh by splitting the elements identified by their pointers, then rebuild the problem. More...  
void  refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined) 
Refine all submeshes by splitting the elements identified by their numbers relative to each submesh in a Vector of Vectors, then rebuild the problem. More...  
void  refine_selected_elements (const Vector< Vector< RefineableElement * >> &elements_to_be_refined_pt) 
Refine all submeshes by splitting the elements identified by their pointers within each submesh in a Vector of Vectors, then rebuild the problem. More...  
void  p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined) 
prefine (one and only!) mesh by refining the elements identified by their numbers relative to the problems' only mesh, then rebuild the problem. More...  
void  p_refine_selected_elements (const Vector< PRefineableElement * > &elements_to_be_refined_pt) 
prefine (one and only!) mesh by refining the elements identified by their pointers, then rebuild the problem. More...  
void  p_refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined) 
prefine specified submesh by refining the elements identified by their numbers relative to the submesh, then rebuild the problem. More...  
void  p_refine_selected_elements (const unsigned &i_mesh, const Vector< PRefineableElement * > &elements_to_be_refined_pt) 
prefine specified submesh by refining the elements identified by their pointers, then rebuild the problem. More...  
void  p_refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined) 
prefine all submeshes by refining the elements identified by their numbers relative to each submesh in a Vector of Vectors, then rebuild the problem. More...  
void  p_refine_selected_elements (const Vector< Vector< PRefineableElement * >> &elements_to_be_refined_pt) 
prefine all submeshes by refining the elements identified by their pointers within each submesh in a Vector of Vectors, then rebuild the problem. More...  
unsigned  unrefine_uniformly () 
Refine (all) refineable (sub)mesh(es) uniformly and rebuild problem. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level) More...  
unsigned  unrefine_uniformly (const unsigned &i_mesh) 
Do uniform refinement for submesh i_mesh without documentation. Return 0 for success, 1 for failure (if unrefinement has reached the coarsest permitted level) More...  
void  p_unrefine_uniformly (DocInfo &doc_info) 
punrefine (all) prefineable (sub)mesh(es) uniformly and rebuild problem. More...  
void  p_unrefine_uniformly (const unsigned &i_mesh, DocInfo &doc_info) 
Do uniform punrefinement for submesh i_mesh without documentation. More...  
void  adapt (unsigned &n_refined, unsigned &n_unrefined) 
Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again. More...  
void  adapt () 
Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. On return from this function, Problem can immediately be solved again. [Argumentfree wrapper]. More...  
void  p_adapt (unsigned &n_refined, unsigned &n_unrefined) 
padapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again. More...  
void  p_adapt () 
padapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on their own error estimates and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. On return from this function, Problem can immediately be solved again. [Argumentfree wrapper] More...  
void  adapt_based_on_error_estimates (unsigned &n_refined, unsigned &n_unrefined, Vector< Vector< double >> &elemental_error) 
Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on the error estimates in elemental_error and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again. More...  
void  adapt_based_on_error_estimates (Vector< Vector< double >> &elemental_error) 
Adapt problem: Perform mesh adaptation for (all) refineable (sub)mesh(es), based on the error estimates in elemental_error and the target errors specified in the mesh(es). Following mesh adaptation, update global mesh, and reassign equation numbers. Return # of refined/unrefined elements. On return from this function, Problem can immediately be solved again. [Wrapper without n_refined and n_unrefined arguments]. More...  
void  get_all_error_estimates (Vector< Vector< double >> &elemental_error) 
Return the error estimates computed by (all) refineable (sub)mesh(es) in the elemental_error structure, which consists of a vector of vectors of elemental errors, one vector for each (sub)mesh. More...  
void  doc_errors (DocInfo &doc_info) 
Get max and min error for all elements in submeshes. More...  
void  doc_errors () 
Get max and min error for all elements in submeshes. More...  
void  enable_info_in_newton_solve () 
Enable the output of information when in the newton solver (Default) More...  
void  disable_info_in_newton_solve () 
Disable the output of information when in the newton solver. More...  
Public Member Functions inherited from oomph::ExplicitTimeSteppableObject  
ExplicitTimeSteppableObject ()  
Empty constructor. More...  
ExplicitTimeSteppableObject (const ExplicitTimeSteppableObject &)=delete  
Broken copy constructor. More...  
void  operator= (const ExplicitTimeSteppableObject &)=delete 
Broken assignment operator. More...  
virtual  ~ExplicitTimeSteppableObject () 
Empty destructor. More...  
virtual void  actions_before_explicit_stage () 
Empty virtual function to do anything needed before a stage of an explicit time step (RungeKutta steps contain multiple stages per time step, most others only contain one). More...  
virtual void  actions_after_explicit_stage () 
Empty virtual function that should be overloaded to update any dependent data or boundary conditions that should be advanced after each stage of an explicit time step (RungeKutta steps contain multiple stages per time step, most others only contain one). More...  
Private Member Functions  
void  backup_original_state () 
Backup original state of all data associated with mesh. More...  
void  reset_original_state () 
Reset original state of all data associated with mesh. More...  
void  setup_problem () 
Change pinned status of all data associated with mesh so that the IC problem can be solved. More...  
Private Attributes  
SolidInitialCondition *  IC_pt 
Pointer to initial condition object. More...  
Vector< int >  Backup_pinned 
Vector to store pinned status of all data. More...  
Vector< Vector< Data * > >  Backup_ext_data 
Vector of Vectors to store pointers to exernal data in the elements. More...  
double  Max_residual_after_consistent_newton_ic 
Max. tolerated residual after application of consistent Newmark IC. Used to check if we have specified the correct timescale ratio (nondim density). More...  
Additional Inherited Members  
Public Types inherited from oomph::Problem  
enum  Distributed_problem_matrix_distribution { Default_matrix_distribution , Problem_matrix_distribution , Uniform_matrix_distribution } 
enum for distribution of distributed jacobians. 1  Automatic  the Problem distribution is employed, unless any processor has number of rows equal to 110% of N/P, in which case uniform distribution is employed. 2  Problem  the jacobian on processor p only contains rows that correspond to equations that are on this processor. (minimises communication) 3  Uniform  each processor holds as close to N/P matrix rows as possible. (very well load balanced) More...  
typedef void(*  SpatialErrorEstimatorFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error) 
Function pointer for spatial error estimator. More...  
typedef void(*  SpatialErrorEstimatorWithDocFctPt) (Mesh *&mesh_pt, Vector< double > &elemental_error, DocInfo &doc_info) 
Function pointer for spatial error estimator with doc. More...  
Public Attributes inherited from oomph::Problem  
double  Max_permitted_error_for_halo_check 
Threshold for error throwing in Problem::check_halo_schemes() More...  
bool  Shut_up_in_newton_solve 
Boolean to indicate if all output is suppressed in Problem::newton_solve(). Defaults to false. More...  
Static Public Attributes inherited from oomph::Problem  
static bool  Suppress_warning_about_actions_before_read_unstructured_meshes 
Flag to allow suppression of warning messages re reading in unstructured meshes during restart. More...  
Protected Types inherited from oomph::Problem  
enum  Assembly_method { Perform_assembly_using_vectors_of_pairs , Perform_assembly_using_two_vectors , Perform_assembly_using_maps , Perform_assembly_using_lists , Perform_assembly_using_two_arrays } 
Enumerated flags to determine which sparse assembly method is used. More...  
Protected Member Functions inherited from oomph::Problem  
unsigned  setup_element_count_per_dof () 
Function that populates the Element_counter_per_dof vector with the number of elements that contribute to each dof. For example, with linear elements in 1D each dof contains contributions from two elements apart from those on the boundary. Returns the total number of elements in the problem. More...  
void  setup_dof_halo_scheme () 
Function that is used to setup the halo scheme. More...  
virtual void  sparse_assemble_row_or_column_compressed (Vector< int * > &column_or_row_index, Vector< int * > &row_or_column_start, Vector< double * > &value, Vector< unsigned > &nnz, Vector< double * > &residual, bool compressed_row_flag) 
Protected helper function that is used to assemble the Jacobian matrix in the case when the storage is row or column compressed. The boolean Flag indicates if we want compressed row format (true) or compressed column. More...  
virtual void  actions_before_newton_convergence_check () 
Any actions that are to be performed before the residual is checked in the Newton method, e.g. update any boundary conditions that depend upon variables of the problem; update any ‘dependent’ variables; or perform an update of the nodal positions in SpineMeshes etc. CAREFUL: This step should (and if the FDbased LinearSolver FD_LU is used, must) only update values that are pinned! More...  
virtual void  actions_before_newton_step () 
Any actions that are to be performed before each individual Newton step. Most likely to be used for diagnostic purposes to doc the solution during a nonconverging iteration, say. More...  
virtual void  actions_after_newton_step () 
Any actions that are to be performed after each individual Newton step. Most likely to be used for diagnostic purposes to doc the solution during a nonconverging iteration, say. More...  
virtual void  actions_before_implicit_timestep () 
Actions that should be performed before each implicit time step. This is needed when one wants to solve a steady problem before timestepping and needs to distinguish between the two cases. More...  
virtual void  actions_after_implicit_timestep () 
Actions that should be performed after each implicit time step. This is needed when one wants to solve a steady problem before timestepping and needs to distinguish between the two cases. More...  
virtual void  actions_after_implicit_timestep_and_error_estimation () 
Actions that should be performed after each implicit time step. This is needed if your actions_after_implicit_timestep() modify the solution in a way that affects the error estimate. More...  
virtual void  actions_before_explicit_timestep () 
Actions that should be performed before each explicit time step. More...  
virtual void  actions_after_explicit_timestep () 
Actions that should be performed after each explicit time step. More...  
virtual void  actions_before_read_unstructured_meshes () 
Actions that are to be performed before reading in restart data for problems involving unstructured bulk meshes. If the problem contains such meshes we need to strip out any face elements that are attached to them because restart of unstructured meshes recreates their elements and nodes from scratch, leading to dangling pointers from the face elements to the old elements and nodes. This function is virtual and (practically) empty but toggles a flag to indicate that it has been called. This is used to issue a warning, prompting the user to consider overloading it if the problem is found to contain unstructured bulk meshes during restarts. More...  
virtual void  actions_after_read_unstructured_meshes () 
Actions that are to be performed before reading in restart data for problems involving unstructured bulk meshes. Typically used to reattach FaceElements, say, that were stripped out in actions_before_read_unstructured_meshes(). This function is virtual and (practically) empty but toggles a flag to indicate that it has been called. This is used to issue a warning, prompting the user to consider overloading it if the problem is found to contain unstructured bulk meshes during restarts. More...  
virtual void  actions_before_distribute () 
Actions to be performed before a (mesh) distribution. More...  
virtual void  actions_after_distribute () 
Actions to be performed after a (mesh) distribution. More...  
virtual void  actions_after_change_in_global_parameter (double *const ¶meter_pt) 
Actions that are to be performed when the global parameter addressed by parameter_pt has been changed in the function get_derivative_wrt_global_parameter() The default is to call actions_before_newton_solve(), actions_before_newton_convergence_check() and actions_after_newton_solve(). This could be amazingly inefficient in certain problems and should be overloaded in such cases. An example would be when a remesh is required in general, but the global parameter does not affect the mesh directly. More...  
virtual void  actions_after_change_in_bifurcation_parameter () 
Actions that are to be performed after a change in the parameter that is being varied as part of the solution of a bifurcation detection problem. The default is to call actions_before_newton_solve(), actions_before_newton_convergence_check() and actions_after_newton_solve(). This could be amazingly inefficient in certain problems and should be overloaded in such cases. An example would be when a remesh is required in general, but the global parameter does not affect the mesh directly. More...  
virtual void  actions_after_parameter_increase (double *const ¶meter_pt) 
Empty virtual function; provides hook to perform actions after the increase in the arclength parameter (during continuation) More...  
double &  dof_derivative (const unsigned &i) 
Access function to the derivative of the ith (local) dof with respect to the arc length, used in continuation. More...  
double &  dof_current (const unsigned &i) 
Access function to the current value of the ith (local) dof at the start of a continuation step. More...  
virtual void  set_initial_condition () 
Set initial condition (incl previous timesteps). We need to establish this interface because I.C. needs to be reset when problem is adapted during the first timestep. More...  
virtual double  global_temporal_error_norm () 
Function to calculate a global error norm, used in adaptive timestepping to control the change in timestep. Individual errors for each data object can be obtained via the data timestepper's temporal_error_in_value or temporal_error_in_position functions and should be combined to construct a global norm. For example, in fluids problems a suitable norm is usually the weighted sum of the errors in the velocities; for moving mesh problems is it usually better to use the weighted sum of the errors in position. More...  
unsigned  newton_solve_continuation (double *const ¶meter_pt) 
Perform a basic arclength continuation step using Newton's method. Returns number of Newton steps taken. More...  
unsigned  newton_solve_continuation (double *const ¶meter_pt, DoubleVector &z) 
This function performs a basic continuation step using the Newton method. The number of Newton steps taken is returned, to be used in any external stepsize control routines. The governing parameter of the problem is passed as a pointer to the routine, as is a vector in which to store the derivatives wrt the parameter, if required. More...  
void  calculate_continuation_derivatives (double *const ¶meter_pt) 
A function to calculate the derivatives wrt the arclength. This version of the function actually does a linear solve so that the derivatives are calculated "exactly" rather than using the values at the Newton step just before convergence. This is necessary in spatially adaptive problems, in which the number of degrees of freedom changes and so the appropriate derivatives must be calculated for the new variables. This function is called if no Newton steps were taken in the continuation routine ... i.e. the initial residuals were sufficiently small. More...  
void  calculate_continuation_derivatives (const DoubleVector &z) 
A function to calculate the derivatives with respect to the arclength required for continuation. The arguments is the solution of the linear system, Jz = dR/dparameter, that gives du/dparameter and the direction output from the newton_solve_continuation function. The derivatives are stored in the ContinuationParameters namespace. More...  
void  calculate_continuation_derivatives_fd (double *const ¶meter_pt) 
A function to calculate the derivatives with respect to the arclength required for continuation by finite differences, using the previous values of the solution. The derivatives are stored in the ContinuationParameters namespace. More...  
bool  does_pointer_correspond_to_problem_data (double *const ¶meter_pt) 
Return a boolean flag to indicate whether the pointer parameter_pt refers to values stored in a Data object that is contained within the problem. More...  
void  set_consistent_pinned_values_for_continuation () 
Private helper function that is used to set the appropriate pinned values for continuation. More...  
Protected Attributes inherited from oomph::Problem  
Vector< Problem * >  Copy_of_problem_pt 
Vector of pointers to copies of the problem used in adaptive bifurcation tracking problems (ALH: TEMPORARY HACK, WILL BE FIXED) More...  
std::map< double *, bool >  Calculate_dparameter_analytic 
Map used to determine whether the derivatives with respect to a parameter should be finite differenced. The default is that finite differences should be used. More...  
bool  Calculate_hessian_products_analytic 
Map used to determine whether the hessian products should be computed using finite differences. The default is that finite differences will be used. More...  
LinearAlgebraDistribution *  Dof_distribution_pt 
The distribution of the DOFs in this problem. This object is created in the Problem constructor and setup when assign_eqn_numbers(...) is called. If this problem is distributed then this distribution will match the distribution of the equation numbers. If this problem is not distributed then this distribution will be uniform over all processors. More...  
Vector< double * >  Dof_pt 
Vector of pointers to dofs. More...  
DoubleVectorWithHaloEntries  Element_count_per_dof 
Counter that records how many elements contribute to each dof. Used to determine the (discrete) arclength automatically. It really should be an integer, but is a double so that the distribution information can be used for distributed problems. More...  
Vector< double >  Elemental_assembly_time 
Storage for assembly times (used for load balancing) More...  
DoubleVectorHaloScheme *  Halo_scheme_pt 
Pointer to the halo scheme for any global vectors that have the Dof_distribution. More...  
Vector< double * >  Halo_dof_pt 
Storage for the halo degrees of freedom (only required) when accessing via the global equation number in distributed problems. More...  
double  Relaxation_factor 
Relaxation fator for Newton method (only a fractional Newton correction is applied if this is less than 1; default 1). More...  
double  Newton_solver_tolerance 
The Tolerance below which the Newton Method is deemed to have converged. More...  
unsigned  Max_newton_iterations 
Maximum number of Newton iterations. More...  
unsigned  Nnewton_iter_taken 
Actual number of Newton iterations taken during the most recent iteration. More...  
Vector< double >  Max_res 
Maximum residuals at start and after each newton iteration. More...  
double  Max_residuals 
Maximum desired residual: if the maximum residual exceeds this value, the program will exit. More...  
bool  Time_adaptive_newton_crash_on_solve_fail 
Bool to specify what to do if a Newton solve fails within a time adaptive solve. Default (false) is to half the step and try again. If true then crash instead. More...  
bool  Jacobian_reuse_is_enabled 
Is reuse of Jacobian in Newton iteration enabled? Default: false. More...  
bool  Jacobian_has_been_computed 
Has a Jacobian been computed (and can therefore be reused if required)? Default: false. More...  
bool  Problem_is_nonlinear 
Boolean flag indicating if we're dealing with a linear or nonlinear Problem – if set to false the Newton solver will not check the residual before or after the linear solve. Set to true by default; can be overwritten in specific Problem class. More...  
bool  Pause_at_end_of_sparse_assembly 
Protected boolean flag to halt program execution during sparse assemble process to assess peak memory usage. Initialised to false (obviously!) More...  
bool  Doc_time_in_distribute 
Protected boolean flag to provide comprehensive timimings during problem distribution. Initialised to false. More...  
unsigned  Sparse_assembly_method 
Flag to determine which sparse assembly method to use By default we use assembly by vectors of pairs. More...  
unsigned  Sparse_assemble_with_arrays_initial_allocation 
the number of elements to initially allocate for a matrix row within the sparse_assembly_with_two_arrays(...) method (if a matrix of this size has not been assembled already). If a matrix of this size has been assembled then the number of elements in each row in that matrix is used as the initial allocation More...  
unsigned  Sparse_assemble_with_arrays_allocation_increment 
the number of elements to add to a matrix row when the initial allocation is exceeded within the sparse_assemble_with_two_arrays(...) method. More...  
Vector< Vector< unsigned > >  Sparse_assemble_with_arrays_previous_allocation 
the number of elements in each row of a compressed matrix in the previous matrix assembly. More...  
double  Numerical_zero_for_sparse_assembly 
A tolerance used to determine whether the entry in a sparse matrix is zero. If it is then storage need not be allocated. More...  
double  FD_step_used_in_get_hessian_vector_products 
bool  Mass_matrix_reuse_is_enabled 
Is reuse of the mass matrix in explicit timestepping enabled Default:false. More...  
bool  Mass_matrix_has_been_computed 
Has the mass matrix been computed (and can therefore be reused) Default: false. More...  
bool  Discontinuous_element_formulation 
Is the problem a discontinuous one, i.e. can the elemental contributions be treated independently. Default: false. More...  
double  Minimum_dt 
Minimum desired dt: if dt falls below this value, exit. More...  
double  Maximum_dt 
Maximum desired dt. More...  
double  DTSF_max_increase 
Maximum possible increase of dt between timesteps in adaptive schemes. More...  
double  DTSF_min_decrease 
Minimum allowed decrease of dt between timesteps in adaptive schemes. Lower scaling values will reject the timestep (and retry with a smaller dt). More...  
double  Minimum_dt_but_still_proceed 
If Minimum_dt_but_still_proceed positive, then dt will not be reduced below this value during adaptive timestepping and the computation will continue with this value, accepting the larger errors that this will incur). Note: This option is disabled by default as this value is initialised to 1.0. More...  
bool  Scale_arc_length 
Boolean to control whether arclength should be scaled. More...  
double  Desired_proportion_of_arc_length 
Proportion of the arclength to taken by the parameter. More...  
double  Theta_squared 
Value of the scaling parameter required so that the parameter occupies the desired proportion of the arc length. NOTE: If you wish to change this then make sure to set the value of Scale_arc_length to false to ensure the value of this isn't overwritten during the arclength process. Instead of changing this variable, it's better to actually update the Desired_proportion_of_arc_length value. More...  
int  Sign_of_jacobian 
Storage for the sign of the global Jacobian. More...  
double  Continuation_direction 
The direction of the change in parameter that will ensure that a branch is followed in one direction only. More...  
double  Parameter_derivative 
Storage for the derivative of the global parameter wrt arclength. More...  
double  Parameter_current 
Storage for the present value of the global parameter. More...  
bool  Use_continuation_timestepper 
Boolean to control original or new storage of dof stuff. More...  
unsigned  Dof_derivative_offset 
Storage for the offset for the continuation derivatives from the original dofs (default is 1, but this will be differnet when continuing bifurcations and periodic orbits) More...  
unsigned  Dof_current_offset 
Storage for the offset for the current values of dofs from the original dofs (default is 2, but this will be differnet when continuing bifurcations and periodic orbits) More...  
Vector< double >  Dof_derivative 
Storage for the derivative of the problem variables wrt arclength. More...  
Vector< double >  Dof_current 
Storage for the present values of the variables. More...  
double  Ds_current 
Storage for the current step value. More...  
unsigned  Desired_newton_iterations_ds 
The desired number of Newton Steps to reach convergence at each step along the arc. More...  
double  Minimum_ds 
Minimum desired value of arclength. More...  
bool  Bifurcation_detection 
Boolean to control bifurcation detection via determinant of Jacobian. More...  
bool  Bisect_to_find_bifurcation 
Boolean to control wheter bisection is used to located bifurcation. More...  
bool  First_jacobian_sign_change 
Boolean to indicate whether a sign change has occured in the Jacobian. More...  
bool  Arc_length_step_taken 
Boolean to indicate whether an arclength step has been taken. More...  
bool  Use_finite_differences_for_continuation_derivatives 
Boolean to specify which scheme to use to calculate the continuation derivatievs. More...  
bool  Problem_has_been_distributed 
Has the problem been distributed amongst multiple processors? More...  
bool  Bypass_increase_in_dof_check_during_pruning 
Boolean to bypass check of increase in dofs during pruning. More...  
OomphCommunicator *  Communicator_pt 
The communicator for this problem. More...  
bool  Always_take_one_newton_step 
Boolean to indicate whether a Newton step should be taken even if the initial residuals are below the required tolerance. More...  
double  Timestep_reduction_factor_after_nonconvergence 
What it says: If temporally adaptive Newton solver fails to to converge, reduce timestep by this factor and try again; defaults to 1/2; can be overwritten by user in derived problem. More...  
bool  Keep_temporal_error_below_tolerance 
Boolean to decide if a timestep is to be rejected if the error estimate postsolve (computed by global_temporal_error_norm()) exceeds the tolerance required in the call to adaptive_unsteady_newton_solve(...). Defaults to true. More...  
Static Protected Attributes inherited from oomph::Problem  
static ContinuationStorageScheme  Continuation_time_stepper 
Storage for the single static continuation timestorage object. More...  
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
IC problem for an elastic body discretised on a given (sub)mesh. We switch the elements' residuals and Jacobians to the system of equations that forces the wall shape to become that of a specified "initial condition object".
Boundary conditions for all data items associated with the mesh's elements' are temporarily overwritten so that all positional dofs (and only those!) become free while all other data (nodal data and the element's internal and external data) are either pinned (for nodal and internal data) or completely removed (for pointers to external data). The complete removal of the (pointers to the) external data is necessary because in FSI problems, positional data of certain elements can feature as external data of others. Hence pinning them in their incarnation as external data would also pin them in their incarnation as positional data.
All data and its pinnedstatus are restored at the end of the call to setup_ic().
Definition at line 87 of file elastic_problems.h.

inline 
Constructor. Initialise pointer to IC object to NULL. Create a dummy mesh that can be deleted when static problem finally goes out of scope at end of program execution.
Create dummy mesh
Definition at line 94 of file elastic_problems.h.
References Max_residual_after_consistent_newton_ic, and oomph::Problem::mesh_pt().

delete 
Broken copy constructor.

inlinevirtual 
Update after solve (empty)
Reimplemented from oomph::Problem.
Definition at line 111 of file elastic_problems.h.

inlinevirtual 
Update the problem specs before solve. (empty)
Reimplemented from oomph::Problem.
Definition at line 114 of file elastic_problems.h.

private 
Backup original state of all data associated with mesh.
Backup pinned status of all data associated with the mesh. Also backup the (pointers to the) elements' external data.
Definition at line 191 of file elastic_problems.cc.
References Backup_ext_data, Backup_pinned, oomph::Mesh::element_pt(), oomph::GeneralisedElement::external_data_pt(), oomph::SolidFiniteElement::has_internal_solid_data(), i, oomph::GeneralisedElement::internal_data_pt(), oomph::Data::is_pinned(), oomph::Problem::mesh_pt(), oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::GeneralisedElement::nexternal_data(), oomph::GeneralisedElement::ninternal_data(), oomph::FiniteElement::nnodal_position_type(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), oomph::SolidNode::position_is_pinned(), and oomph::Global_string_for_annotation::string().
Referenced by set_newmark_initial_condition_consistently(), set_newmark_initial_condition_directly(), and set_static_initial_condition().

inline 
Max. tolerated residual after application of consistent Newmark IC. Used to check if we have specified the correct timescale ratio (nondim density).
Definition at line 172 of file elastic_problems.h.
References Max_residual_after_consistent_newton_ic.

delete 
Broken assignment operator.

private 
Reset original state of all data associated with mesh.
Reset pinned status of all data and reinstate the pointers to the elements' external data.
Definition at line 343 of file elastic_problems.cc.
References oomph::GeneralisedElement::add_external_data(), Backup_ext_data, Backup_pinned, oomph::Mesh::element_pt(), oomph::SolidFiniteElement::has_internal_solid_data(), i, oomph::GeneralisedElement::internal_data_pt(), oomph::Problem::mesh_pt(), oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::GeneralisedElement::ninternal_data(), oomph::FiniteElement::nnodal_position_type(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), oomph::SolidNode::pin_position(), oomph::Global_string_for_annotation::string(), and oomph::Data::unpin().
Referenced by set_newmark_initial_condition_consistently(), set_newmark_initial_condition_directly(), and set_static_initial_condition().
void oomph::SolidICProblem::set_newmark_initial_condition_consistently  (  Problem *  problem_pt, 
Mesh *  mesh_pt,  
TIMESTEPPER *  timestepper_pt,  
SolidInitialCondition *  ic_pt,  
const double &  dt,  
SolidFiniteElement::MultiplierFctPt  multiplier_fct_pt = 0 

) 
Setup initial condition for timeintegration with Newmark's method. Past displacements and velocities are assigned directly (consistent with the idea that a second order ODE can take ICs up to 1st order, while the history value for the previous acceleration is determined by the condition that the weak equation is satisfied at the initial time.) The multiplier function needs to specify the factor that multiplies the inertia terms – typically this is a constant, given by the ratio of the problem's intrinsic timescale to the time used to nondimensionalise the equations. If the function (pointer) is not specified the multiplier is assumed to be equal to 1.0 – appropriate for a nondimensionalisation based on the problem's intrinsic timescale.
Setup initial condition for timeintegration with Newmark's method. Past displacements and velocities are assigned directly (consistent with the idea that a second order ODE can take ICs up to 1st order, while the history value for the previous acceleration is determined by the condition that that the weak equation is satisfied at the initial time. The multiplier function needs to specify the factor that multiplies the inertia terms – typically this is a constant, given by the ratio of the problem's intrinsic timescale to the time used to nondimensionalise the equations. If the function (pointer) is not specified, the multiplier is assumed to be equal to 1.0 – appropriate for a nondimensionalisation based on the problem's intrinsic timescale.
Pointer to member type solver
Definition at line 356 of file elastic_problems.h.
References oomph::Problem::assign_eqn_numbers(), backup_original_state(), oomph::Mesh::element_pt(), oomph::SolidFiniteElement::enable_solve_for_consistent_newmark_accel(), oomph::Data::eqn_number(), oomph::SolidInitialCondition::geom_object_pt(), oomph::Problem::get_residuals(), i, IC_pt, oomph::SolidInitialCondition::ic_time_deriv(), oomph::Problem::linear_solver_pt(), oomph::DoubleVector::max(), Max_residual_after_consistent_newton_ic, oomph::Problem::mesh_pt(), oomph::SolidFiniteElement::multiplier_fct_pt(), oomph::Mesh::nelement(), oomph::Problem::newton_solve(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::TimeStepper::nprev_values(), oomph::TimeStepper::ntstorage(), oomph::Data::nvalue(), oomph::oomph_info, reset_original_state(), oomph::Data::set_value(), setup_problem(), oomph::SolidFiniteElement::solid_ic_pt(), oomph::LinearSolver::solve(), oomph::Time::time(), oomph::TimeStepper::time_pt(), oomph::GeomObject::time_stepper_pt(), oomph::Data::value(), and oomph::Data::value_pt().
void oomph::SolidICProblem::set_newmark_initial_condition_directly  (  Problem *  problem_pt, 
Mesh *  mesh_pt,  
TIMESTEPPER *  timestepper_pt,  
SolidInitialCondition *  ic_pt,  
const double &  dt  
) 
Setup initial condition for timeintegration with Newmark's method. History values are assigned to that the velocity and accelerations determined by the Newmark scheme are exact at the initial time.
Definition at line 212 of file elastic_problems.h.
References oomph::Problem::assign_eqn_numbers(), backup_original_state(), oomph::SolidInitialCondition::geom_object_pt(), IC_pt, oomph::SolidInitialCondition::ic_time_deriv(), oomph::Problem::mesh_pt(), oomph::Problem::newton_solve(), oomph::Mesh::nnode(), oomph::oomph_info, reset_original_state(), setup_problem(), oomph::Time::time(), oomph::TimeStepper::time_pt(), and oomph::GeomObject::time_stepper_pt().

inline 
Force the elastic structure that is discretised on the specified mesh to deform in the shape of the initial condition object (wrapper)
Definition at line 126 of file elastic_problems.h.
References oomph::Problem::mesh_pt(), set_static_initial_condition(), and oomph::Problem::time().
void oomph::SolidICProblem::set_static_initial_condition  (  Problem *  problem_pt, 
Mesh *  mesh_pt,  
SolidInitialCondition *  ic_pt,  
const double &  time  
) 
Force the elastic structure that is discretised on the specified mesh to deform in the shape of the initial condition object (evaluated at the time specified)
IC problem for wall: Deform wall into the static initial shape described by the IC object at given time.
Definition at line 522 of file elastic_problems.cc.
References oomph::Problem::assign_eqn_numbers(), oomph::Problem::assign_initial_values_impulsive(), backup_original_state(), oomph::Problem::Communicator_pt, oomph::Problem::communicator_pt(), oomph::SolidInitialCondition::geom_object_pt(), IC_pt, oomph::SolidInitialCondition::ic_time_deriv(), oomph::Problem::mesh_pt(), oomph::Problem::newton_solve(), oomph::oomph_info, oomph::Problem::Problem_has_been_distributed, oomph::Problem::problem_has_been_distributed(), reset_original_state(), setup_problem(), oomph::Problem::time(), oomph::Time::time(), oomph::TimeStepper::time_pt(), and oomph::GeomObject::time_stepper_pt().
Referenced by set_static_initial_condition().

private 
Change pinned status of all data associated with mesh so that the IC problem can be solved.
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
Setup IC problem by:
Definition at line 48 of file elastic_problems.cc.
References oomph::Problem::assign_eqn_numbers(), oomph::Mesh::element_pt(), oomph::GeneralisedElement::flush_external_data(), oomph::SolidFiniteElement::has_internal_solid_data(), i, IC_pt, oomph::GeneralisedElement::internal_data_pt(), oomph::Problem::mesh_pt(), oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::GeneralisedElement::ninternal_data(), oomph::FiniteElement::nnodal_position_type(), oomph::Mesh::nnode(), oomph::Mesh::node_pt(), oomph::Data::nvalue(), oomph::oomph_info, oomph::Data::pin(), oomph::SolidFiniteElement::solid_ic_pt(), oomph::Global_string_for_annotation::string(), and oomph::SolidNode::unpin_position().
Referenced by set_newmark_initial_condition_consistently(), set_newmark_initial_condition_directly(), and set_static_initial_condition().
Vector of Vectors to store pointers to exernal data in the elements.
Definition at line 196 of file elastic_problems.h.
Referenced by backup_original_state(), and reset_original_state().

private 
Vector to store pinned status of all data.
Definition at line 193 of file elastic_problems.h.
Referenced by backup_original_state(), and reset_original_state().

private 
Pointer to initial condition object.
Definition at line 190 of file elastic_problems.h.
Referenced by set_newmark_initial_condition_consistently(), set_newmark_initial_condition_directly(), set_static_initial_condition(), and setup_problem().

private 
Max. tolerated residual after application of consistent Newmark IC. Used to check if we have specified the correct timescale ratio (nondim density).
Definition at line 201 of file elastic_problems.h.
Referenced by max_residual_after_consistent_newton_ic(), set_newmark_initial_condition_consistently(), and SolidICProblem().