Public Member Functions | Private Member Functions | Private Attributes | List of all members
SheetGlueProblem< ELEMENT > Class Template Reference

Deformation of elastic pouch. More...

+ Inheritance diagram for SheetGlueProblem< ELEMENT >:

Public Member Functions

 SheetGlueProblem ()
 Constructor: More...
 
void run (const std::string &dirname)
 Run simulation. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void actions_after_newton_solve ()
 Update function (empty) More...
 
void create_traction_elements (SolidMesh *traction_mesh_pt, SolidMesh *solid_mesh_pt, const unsigned &b)
 Create traction elements. More...
 
void actions_before_newton_solve ()
 Update before solve: Empty. More...
 
 SheetGlueProblem ()
 Constructor: More...
 
void run (const std::string &dirname)
 Run simulation. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
void actions_after_newton_solve ()
 Update function (empty) More...
 
void create_traction_elements (SolidMesh *traction_mesh_pt, SolidMesh *solid_mesh_pt, const unsigned &b)
 Create traction elements. More...
 
void actions_before_newton_solve ()
 Update before solve: Empty. More...
 
- Public Member Functions inherited from oomph::Problem
virtual void debug_hook_fct (const unsigned &i)
 
void set_analytic_dparameter (double *const &parameter_pt)
 
void unset_analytic_dparameter (double *const &parameter_pt)
 
bool is_dparameter_calculated_analytically (double *const &parameter_pt)
 
void set_analytic_hessian_products ()
 
void unset_analytic_hessian_products ()
 
bool are_hessian_products_calculated_analytically ()
 
void set_pinned_values_to_zero ()
 
bool distributed () const
 
virtual void actions_before_adapt ()
 
virtual void actions_after_adapt ()
 Actions that are to be performed after a mesh adaptation. More...
 
OomphCommunicator * communicator_pt ()
 access function to the oomph-lib communicator More...
 
const OomphCommunicator * communicator_pt () const
 access function to the oomph-lib communicator, const version More...
 
 Problem ()
 
 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)
 
Mesh *const & mesh_pt (const unsigned &imesh) const
 Return a pointer to the i-th submesh (const version) More...
 
unsigned nsub_mesh () const
 Return number of submeshes. More...
 
unsigned add_sub_mesh (Mesh *const &mesh_pt)
 
void flush_sub_meshes ()
 
void build_global_mesh ()
 
void rebuild_global_mesh ()
 
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 ()
 
LinearSolver * mass_matrix_solver_for_explicit_timestepper_pt () const
 
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 ()
 
const TimeStepper * time_stepper_pt () const
 
TimeStepper *& time_stepper_pt (const unsigned &i)
 Return a pointer to the i-th 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)
 
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 ()
 
bool & time_adaptive_newton_crash_on_solve_fail ()
 Access function for Time_adaptive_newton_crash_on_solve_fail. More...
 
double & newton_solver_tolerance ()
 
void add_time_stepper_pt (TimeStepper *const &time_stepper_pt)
 
void set_explicit_time_stepper_pt (ExplicitTimeStepper *const &explicit_time_stepper_pt)
 
void initialise_dt (const double &dt)
 
void initialise_dt (const Vector< double > &dt)
 
Data *& global_data_pt (const unsigned &i)
 Return a pointer to the the i-th global data object. More...
 
void add_global_data (Data *const &global_data_pt)
 
void flush_global_data ()
 
LinearAlgebraDistribution *const & dof_distribution_pt () const
 Return the pointer to the dof distribution (read-only) 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 ()
 Self-test: Check meshes and global data. Return 0 for OK. More...
 
void enable_store_local_dof_pt_in_elements ()
 
void disable_store_local_dof_pt_in_elements ()
 
unsigned long assign_eqn_numbers (const bool &assign_local_eqn_numbers=true)
 
void describe_dofs (std::ostream &out= *(oomph_info.stream_pt())) const
 
void enable_discontinuous_formulation ()
 
void disable_discontinuous_formulation ()
 
void get_dofs (DoubleVector &dofs) const
 
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)
 
void add_to_dofs (const double &lambda, const DoubleVector &increment_dofs)
 Add lambda x incremenet_dofs[l] to the l-th dof. More...
 
double * global_dof_pt (const unsigned &i)
 
double & dof (const unsigned &i)
 i-th dof in the problem More...
 
double dof (const unsigned &i) const
 i-th dof in the problem (const version) More...
 
double *& dof_pt (const unsigned &i)
 Pointer to i-th dof in the problem. More...
 
double * dof_pt (const unsigned &i) const
 Pointer to i-th dof in the problem (const version) More...
 
virtual void get_inverse_mass_matrix_times_residuals (DoubleVector &Mres)
 
virtual void get_dvaluesdt (DoubleVector &f)
 
virtual void get_residuals (DoubleVector &residuals)
 Get the total residuals Vector for the problem. More...
 
virtual void get_jacobian (DoubleVector &residuals, DenseDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CRDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, CCDoubleMatrix &jacobian)
 
virtual void get_jacobian (DoubleVector &residuals, SumOfMatrices &jacobian)
 
void get_fd_jacobian (DoubleVector &residuals, DenseMatrix< double > &jacobian)
 Get the full Jacobian by finite differencing. More...
 
void get_derivative_wrt_global_parameter (double *const &parameter_pt, DoubleVector &result)
 
void get_hessian_vector_products (DoubleVectorWithHaloEntries const &Y, Vector< DoubleVectorWithHaloEntries > const &C, Vector< DoubleVectorWithHaloEntries > &product)
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, Vector< DoubleVector > &eigenvector, const bool &steady=true)
 Solve the eigenproblem. More...
 
void solve_eigenproblem (const unsigned &n_eval, Vector< std::complex< double >> &eigenvalue, const bool &steady=true)
 
virtual void get_eigenproblem_matrices (CRDoubleMatrix &mass_matrix, CRDoubleMatrix &main_matrix, const double &shift=0.0)
 
void assign_eigenvector_to_dofs (DoubleVector &eigenvector)
 Assign the eigenvector passed to the function to the dofs. More...
 
void add_eigenvector_to_dofs (const double &epsilon, const DoubleVector &eigenvector)
 
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 ()
 
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)
 
void steady_newton_solve (unsigned const &max_adapt=0)
 
void copy (Problem *orig_problem_pt)
 
virtual Problem * make_copy ()
 
virtual void read (std::ifstream &restart_file, bool &unsteady_restart)
 
virtual void read (std::ifstream &restart_file)
 
virtual void dump (std::ofstream &dump_file) const
 
void dump (const std::string &dump_file_name) const
 
void delete_all_external_storage ()
 
virtual void symmetrise_eigenfunction_for_adaptive_pitchfork_tracking ()
 
double * bifurcation_parameter_pt () const
 
void get_bifurcation_eigenfunction (Vector< DoubleVector > &eigenfunction)
 
void activate_fold_tracking (double *const &parameter_pt, const bool &block_solve=true)
 
void activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const bool &block_solve=true)
 
void activate_bifurcation_tracking (double *const &parameter_pt, const DoubleVector &eigenvector, const DoubleVector &normalisation, const bool &block_solve=true)
 
void activate_pitchfork_tracking (double *const &parameter_pt, const DoubleVector &symmetry_vector, const bool &block_solve=true)
 
void activate_hopf_tracking (double *const &parameter_pt, const bool &block_solve=true)
 
void activate_hopf_tracking (double *const &parameter_pt, const double &omega, const DoubleVector &null_real, const DoubleVector &null_imag, const bool &block_solve=true)
 
void deactivate_bifurcation_tracking ()
 
void reset_assembly_handler_to_default ()
 Reset the system to the standard non-augemented state. More...
 
double arc_length_step_solve (double *const &parameter_pt, const double &ds, const unsigned &max_adapt=0)
 
double arc_length_step_solve (Data *const &data_pt, const unsigned &data_index, const double &ds, const unsigned &max_adapt=0)
 
void reset_arc_length_parameters ()
 
int & sign_of_jacobian ()
 
void explicit_timestep (const double &dt, const bool &shift_values=true)
 Take an explicit timestep of size dt. More...
 
void unsteady_newton_solve (const double &dt)
 
void unsteady_newton_solve (const double &dt, const bool &shift_values)
 
void unsteady_newton_solve (const double &dt, const unsigned &max_adapt, const bool &first, const bool &shift=true)
 
double doubly_adaptive_unsteady_newton_solve (const double &dt, const double &epsilon, const unsigned &max_adapt, const bool &first, const bool &shift=true)
 
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)
 
double adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon)
 
double adaptive_unsteady_newton_solve (const double &dt_desired, const double &epsilon, const bool &shift_values)
 
void assign_initial_values_impulsive ()
 
void assign_initial_values_impulsive (const double &dt)
 
void calculate_predictions ()
 Calculate predictions. More...
 
void enable_mass_matrix_reuse ()
 
void disable_mass_matrix_reuse ()
 
bool mass_matrix_reuse_is_enabled ()
 Return whether the mass matrix is being reused. More...
 
void refine_uniformly (const Vector< unsigned > &nrefine_for_mesh)
 
void refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)
 
void refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void refine_uniformly (DocInfo &doc_info)
 
void refine_uniformly_and_prune (DocInfo &doc_info)
 
void refine_uniformly ()
 
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)
 
void p_refine_uniformly (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh)
 
void p_refine_uniformly_and_prune (const Vector< unsigned > &nrefine_for_mesh, DocInfo &doc_info)
 
void p_refine_uniformly (DocInfo &doc_info)
 
void p_refine_uniformly_and_prune (DocInfo &doc_info)
 
void p_refine_uniformly ()
 
void p_refine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
 Do uniform p-refinement for submesh i_mesh with documentation. More...
 
void p_refine_uniformly (const unsigned &i_mesh)
 Do uniform p-refinement for submesh i_mesh without documentation. More...
 
void refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)
 
void refine_selected_elements (const Vector< RefineableElement * > &elements_to_be_refined_pt)
 
void refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)
 
void refine_selected_elements (const unsigned &i_mesh, const Vector< RefineableElement * > &elements_to_be_refined_pt)
 
void refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)
 
void refine_selected_elements (const Vector< Vector< RefineableElement * >> &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const Vector< unsigned > &elements_to_be_refined)
 
void p_refine_selected_elements (const Vector< PRefineableElement * > &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const unsigned &i_mesh, const Vector< unsigned > &elements_to_be_refined)
 
void p_refine_selected_elements (const unsigned &i_mesh, const Vector< PRefineableElement * > &elements_to_be_refined_pt)
 
void p_refine_selected_elements (const Vector< Vector< unsigned >> &elements_to_be_refined)
 
void p_refine_selected_elements (const Vector< Vector< PRefineableElement * >> &elements_to_be_refined_pt)
 
unsigned unrefine_uniformly ()
 
unsigned unrefine_uniformly (const unsigned &i_mesh)
 
void p_unrefine_uniformly (DocInfo &doc_info)
 
void p_unrefine_uniformly (const unsigned &i_mesh, DocInfo &doc_info)
 Do uniform p-unrefinement for submesh i_mesh without documentation. More...
 
void adapt (unsigned &n_refined, unsigned &n_unrefined)
 
void adapt ()
 
void p_adapt (unsigned &n_refined, unsigned &n_unrefined)
 
void p_adapt ()
 
void adapt_based_on_error_estimates (unsigned &n_refined, unsigned &n_unrefined, Vector< Vector< double >> &elemental_error)
 
void adapt_based_on_error_estimates (Vector< Vector< double >> &elemental_error)
 
void get_all_error_estimates (Vector< Vector< double >> &elemental_error)
 
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 ()
 
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 ()
 
virtual void actions_after_explicit_stage ()
 

Private Member Functions

void get_unique_nodes_that_meet_sidewalls (const bool &on_left, std::set< SolidNode * > &unique_nodes)
 

Private Attributes

Vector< SolidMesh * > Solid_mesh_pt
 Pointers to solid meshes. More...
 
Vector< SolidMesh * > Traction_mesh_pt
 Pointers to meshes of traction elements. More...
 
GluedSolidMesh * Glued_mesh_pt
 Glued mesh. More...
 

Additional Inherited Members

- Public Types inherited from oomph::Problem
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
bool Shut_up_in_newton_solve
 
- Static Public Attributes inherited from oomph::Problem
static bool Suppress_warning_about_actions_before_read_unstructured_meshes
 
- 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 ()
 
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)
 
virtual void actions_before_newton_convergence_check ()
 
virtual void actions_before_newton_step ()
 
virtual void actions_after_newton_step ()
 
virtual void actions_before_implicit_timestep ()
 
virtual void actions_after_implicit_timestep ()
 
virtual void actions_after_implicit_timestep_and_error_estimation ()
 
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 ()
 
virtual void actions_after_read_unstructured_meshes ()
 
virtual void actions_after_change_in_global_parameter (double *const &parameter_pt)
 
virtual void actions_after_change_in_bifurcation_parameter ()
 
virtual void actions_after_parameter_increase (double *const &parameter_pt)
 
double & dof_derivative (const unsigned &i)
 
double & dof_current (const unsigned &i)
 
virtual void set_initial_condition ()
 
virtual double global_temporal_error_norm ()
 
unsigned newton_solve_continuation (double *const &parameter_pt)
 
unsigned newton_solve_continuation (double *const &parameter_pt, DoubleVector &z)
 
void calculate_continuation_derivatives (double *const &parameter_pt)
 
void calculate_continuation_derivatives (const DoubleVector &z)
 
void calculate_continuation_derivatives_fd (double *const &parameter_pt)
 
bool does_pointer_correspond_to_problem_data (double *const &parameter_pt)
 
void set_consistent_pinned_values_for_continuation ()
 
- Protected Attributes inherited from oomph::Problem
Vector< Problem * > Copy_of_problem_pt
 
std::map< double *, bool > Calculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistribution * Dof_distribution_pt
 
Vector< double * > Dof_pt
 Vector of pointers to dofs. More...
 
DoubleVectorWithHaloEntries Element_count_per_dof
 
double Relaxation_factor
 
double Newton_solver_tolerance
 
unsigned Max_newton_iterations
 Maximum number of Newton iterations. More...
 
unsigned Nnewton_iter_taken
 
Vector< double > Max_res
 Maximum residuals at start and after each newton iteration. More...
 
double Max_residuals
 
bool Time_adaptive_newton_crash_on_solve_fail
 
bool Jacobian_reuse_is_enabled
 Is re-use of Jacobian in Newton iteration enabled? Default: false. More...
 
bool Jacobian_has_been_computed
 
bool Problem_is_nonlinear
 
bool Pause_at_end_of_sparse_assembly
 
bool Doc_time_in_distribute
 
unsigned Sparse_assembly_method
 
unsigned Sparse_assemble_with_arrays_initial_allocation
 
unsigned Sparse_assemble_with_arrays_allocation_increment
 
Vector< Vector< unsigned > > Sparse_assemble_with_arrays_previous_allocation
 
double Numerical_zero_for_sparse_assembly
 
double FD_step_used_in_get_hessian_vector_products
 
bool Mass_matrix_reuse_is_enabled
 
bool Mass_matrix_has_been_computed
 
bool Discontinuous_element_formulation
 
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
 
double DTSF_min_decrease
 
double Minimum_dt_but_still_proceed
 
bool Scale_arc_length
 Boolean to control whether arc-length should be scaled. More...
 
double Desired_proportion_of_arc_length
 Proportion of the arc-length to taken by the parameter. More...
 
double Theta_squared
 
int Sign_of_jacobian
 Storage for the sign of the global Jacobian. More...
 
double Continuation_direction
 
double Parameter_derivative
 Storage for the derivative of the global parameter wrt arc-length. 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
 
unsigned Dof_current_offset
 
Vector< double > Dof_derivative
 Storage for the derivative of the problem variables wrt arc-length. 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
 
double Minimum_ds
 Minimum desired value of arc-length. 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 arc-length step has been taken. More...
 
bool Use_finite_differences_for_continuation_derivatives
 
OomphCommunicator * Communicator_pt
 The communicator for this problem. More...
 
bool Always_take_one_newton_step
 
double Timestep_reduction_factor_after_nonconvergence
 
bool Keep_temporal_error_below_tolerance
 
- Static Protected Attributes inherited from oomph::Problem
static ContinuationStorageScheme Continuation_time_stepper
 Storage for the single static continuation timestorage object. More...
 

Detailed Description

template<class ELEMENT>
class SheetGlueProblem< ELEMENT >

Deformation of elastic pouch.

Constructor & Destructor Documentation

◆ SheetGlueProblem() [1/2]

template<class ELEMENT >
SheetGlueProblem< ELEMENT >::SheetGlueProblem

Constructor:

174  {
175 
176  bool glue_it = true;
177 
178  Problem::Max_newton_iterations = 20;
179 
180  // make space for meshes
181  unsigned n_mesh = 2;
182  Solid_mesh_pt.resize(n_mesh);
183  Traction_mesh_pt.resize(n_mesh);
184 
185  // How thick is the sheet?
186  double sheet_thickness = 0.1;
187 
188  // Sheet dimensions
189  double x_min = -sheet_thickness / 2.0;
190  double x_max = sheet_thickness / 2.0;
191  double y_min = -1.0;
192  double y_max = 1.0;
193  double z_min = -1.0;
194  double z_max = 1.0;
195 
196  // Elements
197  unsigned n_x = 2;
198  unsigned n_y = 5;
199  unsigned n_z = 5;
200 
201  // Width of glued layer:
202  double glue_layer_width_y = 2.0 / double(n_y);
203  double glue_layer_width_z = 2.0 / double(n_z);
204 
205 
206  // Create bulk meshes
207  for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++) {
208  //Now create the mesh
209  Solid_mesh_pt[i_mesh] = new RefineableSolidCubicMesh<ELEMENT>(n_x, n_y, n_z,
210  x_min, x_max,
211  y_min, y_max,
212  z_min, z_max);
213 
214  //Output boundaries
215  std::string filename = "mesh_boundaries" + to_string(i_mesh) + ".dat";
216  Solid_mesh_pt[i_mesh]->output_boundaries(filename);
217 
218  // Solid mesh is first sub-mesh
219  if (!glue_it) {
220  add_sub_mesh(Solid_mesh_pt[i_mesh]);
221  }
222 
223  //Loop over the elements in the mesh to set parameters/function pointers
224  unsigned n_element = Solid_mesh_pt[i_mesh]->nelement();
225  for (unsigned i = 0; i < n_element; i++) {
226  //Cast to a solid element
227  ELEMENT *el_pt =
228  dynamic_cast<ELEMENT *>(Solid_mesh_pt[i_mesh]->element_pt(i));
229 
230  // Set the constitutive law
231  el_pt->constitutive_law_pt() =
232  Global_Physical_Variables::Constitutive_law_pt;
233  }
234 
235 
236  // Setup boundary conditions
237  //--------------------------
238 
239  // hierher: use
240  bool minimal_constraint = true;
241 
242  // Suppress rigid body modes by pinning six displacements
243  //--------------------------------------------------------
244  // at lower-left, etc. nodes on
245  //------------------------------
246  // const y face at the glued end of the first sheet
247  //-------------------------------------------------
248  if (i_mesh == 0) {
249 
250  unsigned b = 4;
251  SolidNode *ll_node_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, 0);
252  SolidNode *ur_node_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, 0);
253  SolidNode *ul_node_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, 0);
254  SolidNode *lr_node_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, 0);
255 
256  unsigned n_node = Solid_mesh_pt[i_mesh]->nboundary_node(b);
257  for (unsigned n = 0; n < n_node; n++) {
258  SolidNode *nod_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, n);
259  double y = nod_pt->x(1);
260  double z = nod_pt->x(2);
261  if ((y <= ll_node_pt->x(1)) && (z <= ll_node_pt->x(2))) {
262  ll_node_pt = nod_pt;
263  }
264  if ((y <= ul_node_pt->x(1)) && (z >= ul_node_pt->x(2))) {
265  ul_node_pt = nod_pt;
266  }
267  if ((y >= ur_node_pt->x(1)) && (z >= ur_node_pt->x(2))) {
268  ur_node_pt = nod_pt;
269  }
270  if ((y >= lr_node_pt->x(1)) && (z <= lr_node_pt->x(2))) {
271  lr_node_pt = nod_pt;
272  }
273  }
274 
275  // Note sharp deformation near ll node because it has to balance
276  // the entire z force exerted downwards by the pressure acting on the
277  // increasingly inflated pouch
278 
279  // Suppress rigid body motion
280  ll_node_pt->pin_position(0);
281  ll_node_pt->pin_position(1);
282  ll_node_pt->pin_position(2);
283 
284  // Suppress rotation about x and y axes
285  ul_node_pt->pin_position(0);
286  ul_node_pt->pin_position(1);
287 
288  // suppress rotation about z axis
289  lr_node_pt->pin_position(0);
290 
291  oomph_info << "Pinning at: \n"
292  << ll_node_pt->x(0) << " "
293  << ll_node_pt->x(1) << " "
294  << ll_node_pt->x(2) << "\n"
295  << ul_node_pt->x(0) << " "
296  << ul_node_pt->x(1) << " "
297  << ul_node_pt->x(2) << "\n"
298  << lr_node_pt->x(0) << " "
299  << lr_node_pt->x(1) << " "
300  << lr_node_pt->x(2) << "\n";
301 
302  }
303 
304  //######################################################################
305 
306 
307  // // y=0
308  // //----
309  // {
310  // unsigned b=1;
311  // unsigned n_node = Solid_mesh_pt[i_mesh]->nboundary_node(b);
312  // for(unsigned n=0;n<n_node;n++)
313  // {
314  // //Pin all nodes
315  // for(unsigned i=0;i<3;i++)
316  // {
317  // Solid_mesh_pt[i_mesh]->boundary_node_pt(b,n)->pin_position(i);
318  // }
319  // }
320  // }
321  // // y=1
322  // //----
323  // {
324  // unsigned b=3;
325  // unsigned n_node = Solid_mesh_pt[i_mesh]->nboundary_node(b);
326  // for(unsigned n=0;n<n_node;n++)
327  // {
328  // //Pin all nodes
329  // for(unsigned i=0;i<3;i++)
330  // {
331  // Solid_mesh_pt[i_mesh]->boundary_node_pt(b,n)->pin_position(i);
332  // }
333  // }
334  // }
335 
336  //######################################################################
337 
338  // Pin the redundant solid pressures
339  PVDEquationsBase<3>::pin_redundant_nodal_solid_pressures(
340  Solid_mesh_pt[i_mesh]->element_pt());
341  }
342 
343 
344  // Shift second sheet:
345  unsigned nnode = Solid_mesh_pt[1]->nnode();
346  for (unsigned j = 0; j < nnode; j++) {
347  Solid_mesh_pt[1]->node_pt(j)->x(0) += sheet_thickness;
348  }
349  Solid_mesh_pt[1]->set_lagrangian_nodal_coordinates();
350 
351 
352  if (glue_it) {
353  // Create glued mesh
354  Glued_mesh_pt = new GluedSolidMesh(Solid_mesh_pt);
355 
356 
357  // Select nodes to be glued:
358  //--------------------------
359 
360  // We retain them on mesh 0 where the glued
361  // nodes are on boundary 2
362  {
363  double tol = 1.0e-2;
364  unsigned i_mesh = 0;
365  unsigned b = 2;
366  unsigned n_node = Solid_mesh_pt[i_mesh]->nboundary_node(b);
367  oomph_info << "# of glue nodes: " << n_node << std::endl;
368  Vector<Node *> glue_node_pt;
369  glue_node_pt.reserve(n_node);
370  for (unsigned n = 0; n < n_node; n++) {
371  Node *potential_node_pt = Solid_mesh_pt[i_mesh]->boundary_node_pt(b, n);
372  if (
373  (potential_node_pt->x(1) < (y_min + glue_layer_width_y + tol)) ||
374  (potential_node_pt->x(1) > (y_max - glue_layer_width_y - tol)) ||
375  (potential_node_pt->x(2) < (z_min + glue_layer_width_z + tol))) {
376  glue_node_pt.push_back(potential_node_pt);
377  }
378  }
379 
380  // Glue specified nodes to co-located nodes in consituent mesh 1
381  unsigned i_mesh_replace = 1;
382  Glued_mesh_pt->glue(glue_node_pt, i_mesh_replace);
383 
384  // Add to global mesh
385  add_sub_mesh(Glued_mesh_pt);
386  }
387  } else {
388  Glued_mesh_pt = 0;
389  }
390 
391 
392  // Create traction meshes (attach to elements in still existing
393  //-------------------------------------------------------------
394  // original meshes)
395  //-----------------
396  for (unsigned i_mesh = 0; i_mesh < n_mesh; i_mesh++) {
397  // Make new mesh
398  Traction_mesh_pt[i_mesh] = new SolidMesh;
399 
400  // Create elements on x=1
401  unsigned b = 2;
402  if (i_mesh == 1) {
403  b = 4;
404  }
405  create_traction_elements(Traction_mesh_pt[i_mesh], Solid_mesh_pt[i_mesh], b);
406 
407  // Add it!
408  add_sub_mesh(Traction_mesh_pt[i_mesh]);
409  }
410 
411 
412  // Build combined "global" mesh
413  build_global_mesh();
414 
415 
416  //Attach the boundary conditions to the mesh
417  cout << assign_eqn_numbers() << std::endl;
418 
419 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
b
Scalar * b
Definition: benchVecAdd.cpp:17
GluedSolidMesh
Definition: glued_mesh_stuff.h:25
GluedSolidMesh::glue
void glue(const Vector< Node * > glue_node_pt, const unsigned &i_mesh_replace)
Definition: glued_mesh_stuff.h:77
SheetGlueProblem::Traction_mesh_pt
Vector< SolidMesh * > Traction_mesh_pt
Pointers to meshes of traction elements.
Definition: TwenteMeshGluing.cpp:163
SheetGlueProblem::Solid_mesh_pt
Vector< SolidMesh * > Solid_mesh_pt
Pointers to solid meshes.
Definition: TwenteMeshGluing.cpp:160
SheetGlueProblem::Glued_mesh_pt
GluedSolidMesh * Glued_mesh_pt
Glued mesh.
Definition: TwenteMeshGluing.cpp:166
SheetGlueProblem::create_traction_elements
void create_traction_elements(SolidMesh *traction_mesh_pt, SolidMesh *solid_mesh_pt, const unsigned &b)
Create traction elements.
Definition: TwenteMeshGluing.cpp:120
oomph::Node
Definition: nodes.h:906
oomph::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
oomph::PVDEquationsBase
Definition: solid_elements.h:58
oomph::Problem::add_sub_mesh
unsigned add_sub_mesh(Mesh *const &mesh_pt)
Definition: problem.h:1330
oomph::Problem::build_global_mesh
void build_global_mesh()
Definition: problem.cc:1493
oomph::Problem::assign_eqn_numbers
unsigned long assign_eqn_numbers(const bool &assign_local_eqn_numbers=true)
Definition: problem.cc:1989
oomph::RefineableSolidCubicMesh
Definition: solid_cubic_mesh.h:17
oomph::SolidMesh
Definition: mesh.h:2562
oomph::SolidNode
Definition: nodes.h:1686
oomph::SolidNode::pin_position
void pin_position(const unsigned &i)
Pin the nodal position.
Definition: nodes.h:1816
y
Scalar * y
Definition: level1_cplx_impl.h:128
Global_Physical_Variables::Constitutive_law_pt
ConstitutiveLaw * Constitutive_law_pt
Pointer to constitutive law.
Definition: TwenteMeshGluing.cpp:65
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39
oomph::Global_string_for_annotation::string
std::string string(const unsigned &i)
Definition: oomph_definitions.cc:286
oomph::Locate_zeta_helpers::Max_newton_iterations
unsigned Max_newton_iterations
Maximum number of newton iterations.
Definition: elements.cc:1654
oomph::StringConversion::to_string
std::string to_string(T object, unsigned float_precision=8)
Definition: oomph_utilities.h:189
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319
plotDoE.x
list x
Definition: plotDoE.py:28
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References b, Global_Physical_Variables::Constitutive_law_pt, MergeRestartFiles::filename, i, j, oomph::Locate_zeta_helpers::Max_newton_iterations, n, oomph::oomph_info, oomph::SolidNode::pin_position(), oomph::Global_string_for_annotation::string(), oomph::StringConversion::to_string(), plotDoE::x, oomph::Node::x(), and y.

◆ SheetGlueProblem() [2/2]

template<class ELEMENT >
SheetGlueProblem< ELEMENT >::SheetGlueProblem ( )

Constructor:

Member Function Documentation

◆ actions_after_newton_solve() [1/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

116 {}

◆ actions_after_newton_solve() [2/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::actions_after_newton_solve ( )
inlinevirtual

Update function (empty)

Reimplemented from oomph::Problem.

113 {}

◆ actions_before_newton_solve() [1/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update before solve: Empty.

Reimplemented from oomph::Problem.

155 {}

◆ actions_before_newton_solve() [2/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::actions_before_newton_solve ( )
inlinevirtual

Update before solve: Empty.

Reimplemented from oomph::Problem.

154 {}

◆ create_traction_elements() [1/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::create_traction_elements ( SolidMesh *  traction_mesh_pt,
SolidMesh *  solid_mesh_pt,
const unsigned &  b 
)
inline

Create traction elements.

122  {
123  unsigned n_element = solid_mesh_pt->nboundary_element(b);
124  for (unsigned e = 0; e < n_element; e++) {
125  // The element itself:
126  FiniteElement *fe_pt = solid_mesh_pt->boundary_element_pt(b, e);
127 
128  // Find the index of the face of element e along boundary b
129  int face_index = solid_mesh_pt->face_index_at_boundary(b, e);
130 
131 
132  // Create new element
133  traction_mesh_pt->add_element_pt(
134  new SolidTractionElement<ELEMENT>
135  (fe_pt, face_index));
136 
137  }
138 
139  // Complete build process for SolidTractionElements
140  n_element = traction_mesh_pt->nelement();
141  for (unsigned i = 0; i < n_element; i++) {
142 
143  //Cast to a solid traction element
144  SolidTractionElement<ELEMENT> *el_pt =
145  dynamic_cast<SolidTractionElement<ELEMENT> *>
146  (traction_mesh_pt->element_pt(i));
147 
148  //Set the traction function
149  el_pt->traction_fct_pt() = Global_Physical_Variables::constant_pressure;
150  }
151 
152  }
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
oomph::FiniteElement
Definition: elements.h:1313
oomph::Mesh::face_index_at_boundary
int face_index_at_boundary(const unsigned &b, const unsigned &e) const
Definition: mesh.h:896
oomph::Mesh::nboundary_element
unsigned nboundary_element(const unsigned &b) const
Return number of finite elements that are adjacent to boundary b.
Definition: mesh.h:878
oomph::Mesh::boundary_element_pt
FiniteElement * boundary_element_pt(const unsigned &b, const unsigned &e) const
Return pointer to e-th finite element on boundary b.
Definition: mesh.h:840
oomph::Mesh::element_pt
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
oomph::Mesh::add_element_pt
void add_element_pt(GeneralisedElement *const &element_pt)
Add a (pointer to) an element to the mesh.
Definition: mesh.h:617
oomph::Mesh::nelement
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590
oomph::SolidTractionElement
Definition: solid_traction_elements.h:78
oomph::SolidTractionElement::traction_fct_pt
void(*&)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction) traction_fct_pt()
Reference to the traction function pointer.
Definition: solid_traction_elements.h:159
Global_Physical_Variables::constant_pressure
void constant_pressure(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
Constant pressure load.
Definition: TwenteMeshGluing.cpp:80

References oomph::Mesh::add_element_pt(), b, oomph::Mesh::boundary_element_pt(), Global_Physical_Variables::constant_pressure(), e(), oomph::Mesh::element_pt(), oomph::Mesh::face_index_at_boundary(), i, oomph::Mesh::nboundary_element(), oomph::Mesh::nelement(), and oomph::SolidTractionElement< ELEMENT >::traction_fct_pt.

◆ create_traction_elements() [2/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::create_traction_elements ( SolidMesh *  traction_mesh_pt,
SolidMesh *  solid_mesh_pt,
const unsigned &  b 
)
inline

Create traction elements.

119  {
120  unsigned n_element = solid_mesh_pt->nboundary_element(b);
121  for (unsigned e=0;e<n_element;e++)
122  {
123  // The element itself:
124  FiniteElement* fe_pt = solid_mesh_pt->boundary_element_pt(b,e);
125 
126  // Find the index of the face of element e along boundary b
127  int face_index = solid_mesh_pt->face_index_at_boundary(b,e);
128 
129  // Create new element
130  traction_mesh_pt->add_element_pt(
131  new SolidTractionElement<ELEMENT>
132  (fe_pt,face_index));
133 
134  }
135 
136  // Complete build process for SolidTractionElements
137  n_element=traction_mesh_pt->nelement();
138  for(unsigned i=0;i<n_element;i++)
139  {
140 
141  //Cast to a solid traction element
142  SolidTractionElement<ELEMENT> *el_pt =
143  dynamic_cast<SolidTractionElement<ELEMENT>*>
144  (traction_mesh_pt->element_pt(i));
145 
146  //Set the traction function
147  el_pt->traction_fct_pt() = Global_Physical_Variables::constant_pressure;
148  }
149 
150  }

References oomph::Mesh::add_element_pt(), b, oomph::Mesh::boundary_element_pt(), Global_Physical_Variables::constant_pressure(), e(), oomph::Mesh::element_pt(), oomph::Mesh::face_index_at_boundary(), i, oomph::Mesh::nboundary_element(), oomph::Mesh::nelement(), and oomph::SolidTractionElement< ELEMENT >::traction_fct_pt.

◆ doc_solution() [1/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

426  {
427 
428  ofstream some_file;
429  char filename[100];
430 
431  // Number of plot points
432  unsigned npts = 5;
433 
434  // Output shape of deformed body
435  sprintf(filename, "%s/sol1n%i.dat", doc_info.directory().c_str(),
436  doc_info.number());
437  some_file.open(filename);
438  Solid_mesh_pt[0]->output(some_file, npts);
439  Solid_mesh_pt[1]->output(some_file, npts);
440  some_file.close();
441 
442  // Output traction
443  //----------------
444  sprintf(filename, "%s/traction%i.dat", doc_info.directory().c_str(),
445  doc_info.number());
446  some_file.open(filename);
447  Traction_mesh_pt[0]->output(some_file, npts);
448  Traction_mesh_pt[1]->output(some_file, npts);
449  some_file.close();
450 
451 
452  // Output glued mesh
453  //------------------
454  if (Glued_mesh_pt != 0) {
455  sprintf(filename, "%s/glued_sol1n%i.dat", doc_info.directory().c_str(),
456  doc_info.number());
457  some_file.open(filename);
458  Glued_mesh_pt->output(some_file, npts);
459  some_file.close();
460  }
461 
462 }
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554

References oomph::DocInfo::directory(), MergeRestartFiles::filename, and oomph::DocInfo::number().

◆ doc_solution() [2/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::doc_solution ( DocInfo &  doc_info)

Doc the solution.

◆ get_unique_nodes_that_meet_sidewalls()

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::get_unique_nodes_that_meet_sidewalls ( const bool &  on_left,
std::set< SolidNode * > &  unique_nodes 
)
inlineprivate

Helper function to get unique nodes of central sheets where they meet the sidewalls. This happens after the colocated nodes have been glued together, so visiting them through the boundary lookup schemes of the glued mesh's constituent meshes produces duplicates.

167  {
168 
169  // Wipe
170  unique_nodes.clear();
171 
172  // On left (min. y) or right (max. y)?
173  unsigned b=1;
174  if (!on_left)
175  {
176  b=3;
177  }
178 
179  // Populate set
180  for (unsigned i_mesh=0;i_mesh<4;i_mesh++)
181  {
182  unsigned n_node = Solid_mesh_pt[i_mesh]->nboundary_node(b);
183  for(unsigned n=0;n<n_node;n++)
184  {
185  unique_nodes.insert(Solid_mesh_pt[i_mesh]->boundary_node_pt(b,n));
186  }
187  }
188 
189  // oomph_info << "Unique nodes on ";
190  // if (on_left)
191  // {
192  // oomph_info << "left : ";
193  // }
194  // else
195  // {
196  // oomph_info << "right: ";
197  // }
198  // oomph_info << unique_nodes.size() << std::endl;
199 
200  }

References b, and n.

◆ run() [1/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::run ( const std::string &  dirname)

Run simulation.

Run the problem.

469  {
470 
471  // Output
472  DocInfo doc_info;
473 
474  // Set output directory
475  doc_info.set_directory(dirname);
476 
477  // Step number
478  doc_info.number() = 0;
479 
480  // Doc initial configuration
481  doc_solution(doc_info);
482  doc_info.number()++;
483 
484 
485  // Pressure increment
486  double dp = 0.0005;
487  Global_Physical_Variables::P = 0.0; // dp;
488 
489  //Parameter incrementation
490  unsigned nstep = 10;
491  if (CommandLineArgs::Argc != 1) {
492  std::cout << "Validation -- only doing one step" << std::endl;
493  nstep = 1;
494  }
495 
496  for (unsigned i = 0; i < nstep; i++) {
497 
498  // Solve the problem with Newton's method
499  newton_solve();
500 
501  // Doc solution
502  doc_solution(doc_info);
503  doc_info.number()++;
504 
505  //Increase the pressure
506  Global_Physical_Variables::P += dp;
507  }
508 
509 }
SheetGlueProblem::doc_solution
void doc_solution(DocInfo &doc_info)
Doc the solution.
Definition: TwenteMeshGluing.cpp:426
oomph::DocInfo
Definition: oomph_utilities.h:499
oomph::DocInfo::set_directory
void set_directory(const std::string &directory)
Definition: oomph_utilities.cc:298
oomph::Problem::newton_solve
void newton_solve()
Use Newton method to solve the problem.
Definition: problem.cc:8783
Global_Physical_Variables::P
double P
Uniform pressure.
Definition: TwenteMeshGluing.cpp:77
oomph::CommandLineArgs::Argc
int Argc
Number of arguments + 1.
Definition: oomph_utilities.cc:407

References oomph::CommandLineArgs::Argc, i, oomph::DocInfo::number(), Global_Physical_Variables::P, and oomph::DocInfo::set_directory().

◆ run() [2/2]

template<class ELEMENT >
void SheetGlueProblem< ELEMENT >::run ( const std::string &  dirname)

Run simulation.

Member Data Documentation

◆ Glued_mesh_pt

template<class ELEMENT >
GluedSolidMesh * SheetGlueProblem< ELEMENT >::Glued_mesh_pt
private

Glued mesh.

◆ Solid_mesh_pt

template<class ELEMENT >
Vector< SolidMesh * > SheetGlueProblem< ELEMENT >::Solid_mesh_pt
private

Pointers to solid meshes.

◆ Traction_mesh_pt

template<class ELEMENT >
Vector< SolidMesh * > SheetGlueProblem< ELEMENT >::Traction_mesh_pt
private

Pointers to meshes of traction elements.

The documentation for this class was generated from the following files: