UnstructuredSolidProblem< ELEMENT, MESH > Class Template Reference

Unstructured solid problem. More...

+ Inheritance diagram for UnstructuredSolidProblem< ELEMENT, MESH >:

Public Member Functions

 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void set_incompressible ()
 Set the problem to be incompressible. More...
 
void doc_solution ()
 Doc the solution. More...
 
double get_strain_energy ()
 Calculate the strain energy. More...
 
void actions_before_adapt ()
 Remove Traction Mesh. More...
 
void actions_after_adapt ()
 Add on the traction elements after adaptation. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void doc_solution ()
 Doc the solution. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void set_incompressible ()
 Set the problem to be incompressible. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
double get_strain_energy ()
 Calculate the strain energy. More...
 
void actions_before_adapt ()
 Remove Traction Mesh. More...
 
void actions_after_adapt ()
 Add on the traction elements after adaptation. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve: empty. More...
 
void actions_after_newton_solve ()
 Update the problem specs before solve: empty. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. More...
 
 UnstructuredSolidProblem ()
 Constructor: More...
 
 ~UnstructuredSolidProblem ()
 Destructor (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve: empty. More...
 
void actions_after_newton_solve ()
 Update the problem specs before solve: empty. More...
 
void doc_solution (DocInfo &doc_info)
 Doc the solution. 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
 
OomphCommunicatorcommunicator_pt ()
 access function to the oomph-lib communicator More...
 
const OomphCommunicatorcommunicator_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 ()
 
LinearSolvermass_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...
 
Timetime_pt () const
 Return a pointer to the global time object (const version). More...
 
doubletime ()
 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 TimeSteppertime_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...
 
doubleminimum_dt ()
 Access function to min timestep in adaptive timestepping. More...
 
doublemaximum_dt ()
 Access function to max timestep in adaptive timestepping. More...
 
unsignedmax_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...
 
doublemax_residuals ()
 
booltime_adaptive_newton_crash_on_solve_fail ()
 Access function for Time_adaptive_newton_crash_on_solve_fail. More...
 
doublenewton_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...
 
doubleglobal_dof_pt (const unsigned &i)
 
doubledof (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...
 
doubledof_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...
 
booluse_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 Problemmake_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 ()
 
doublebifurcation_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 ()
 
intsign_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 create_traction_elements ()
 Create traction elements. More...
 
void create_traction_elements ()
 Create traction elements. More...
 

Private Attributes

MESH * Solid_mesh_pt
 Bulk mesh. More...
 
SolidMeshTraction_mesh_pt
 Pointer to mesh of traction elements. More...
 
TriangleMeshPolygonOuter_boundary_polyline_pt
 Triangle mesh polygon for outer boundary. More...
 
bool Incompressible
 Boolean flag used in an incompressible problem. More...
 
ofstream Trace_file
 Trace file. More...
 
DocInfo Doc_info
 DocInfo object for output. More...
 
ElasticQuadFromTriangleMesh< ELEMENT > * Solid_mesh_pt
 Bulk mesh. More...
 
RefineableSolidTriangleMesh< ELEMENT > * Solid_mesh_pt
 Bulk mesh. More...
 
ElasticTetMesh< ELEMENT > * Solid_mesh_pt
 Bulk mesh. More...
 
ElasticTriangleMesh< ELEMENT > * Solid_mesh_pt
 Bulk mesh. More...
 
MySolidTetgenMesh< ELEMENT > * Solid_mesh_pt
 Bulk solid mesh. More...
 
Vector< SolidMesh * > Solid_traction_mesh_pt
 Meshes of traction elements. More...
 
Vector< unsignedPinned_solid_boundary_id
 IDs of solid mesh boundaries where displacements are pinned. More...
 
Vector< unsignedSolid_traction_boundary_id
 IDs of solid mesh boundaries which make up the traction interface. 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)
 
doubledof_derivative (const unsigned &i)
 
doubledof_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 *, boolCalculate_dparameter_analytic
 
bool Calculate_hessian_products_analytic
 
LinearAlgebraDistributionDof_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< doubleMax_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< doubleDof_derivative
 Storage for the derivative of the problem variables wrt arc-length. More...
 
Vector< doubleDof_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
 
OomphCommunicatorCommunicator_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 MESH>
class UnstructuredSolidProblem< ELEMENT, MESH >

Unstructured solid problem.

Constructor & Destructor Documentation

◆ UnstructuredSolidProblem() [1/7]

template<class ELEMENT >
UnstructuredSolidProblem< ELEMENT >::UnstructuredSolidProblem

Constructor:

Constructor for unstructured solid problem.

IDs of solid mesh boundaries where displacements are pinned

169  :
170  Incompressible(false)
171 {
172  // Build the boundary segments for outer boundary, consisting of
173  //--------------------------------------------------------------
174  // four separeate polyline segments
175  //---------------------------------
176  Vector<TriangleMeshCurveSection*> boundary_segment_pt(4);
177 
178  // Initialize boundary segment
179  Vector<Vector<double> > bound_seg(2);
180  for(unsigned i=0;i<2;i++) {bound_seg[i].resize(2);}
181 
182  // First boundary segment
183  bound_seg[0][0]=0.0;
184  bound_seg[0][1]=0.0;
185  bound_seg[1][0]=0.0;
186  bound_seg[1][1]=5.0;
187 
188  // Specify 1st boundary id
189  unsigned bound_id = 0;
190 
191  // Build the 1st boundary segment
192  boundary_segment_pt[0] = new TriangleMeshPolyLine(bound_seg,bound_id);
193 
194  // Second boundary segment
195  bound_seg[0][0]=0.0;
196  bound_seg[0][1]=5.0;
197  bound_seg[1][0]=1.0;
198  bound_seg[1][1]=5.0;
199 
200  // Specify 2nd boundary id
201  bound_id = 1;
202 
203  // Build the 2nd boundary segment
204  boundary_segment_pt[1] = new TriangleMeshPolyLine(bound_seg,bound_id);
205 
206  // Third boundary segment
207  bound_seg[0][0]=1.0;
208  bound_seg[0][1]=5.0;
209  bound_seg[1][0]=1.0;
210  bound_seg[1][1]=0.0;
211 
212  // Specify 3rd boundary id
213  bound_id = 2;
214 
215  // Build the 3rd boundary segment
216  boundary_segment_pt[2] = new TriangleMeshPolyLine(bound_seg,bound_id);
217 
218  // Fourth boundary segment
219  bound_seg[0][0]=1.0;
220  bound_seg[0][1]=0.0;
221  bound_seg[1][0]=0.0;
222  bound_seg[1][1]=0.0;
223 
224  // Specify 4th boundary id
225  bound_id = 3;
226 
227  // Build the 4th boundary segment
228  boundary_segment_pt[3] = new TriangleMeshPolyLine(bound_seg,bound_id);
229 
230  // Create the triangle mesh polygon for outer boundary using boundary segment
231  Outer_boundary_polyline_pt = new TriangleMeshPolygon(boundary_segment_pt);
232 
233 
234  // There are no holes. Now build the mesh, based on the
235  //-----------------------------------------------------
236  // boundaries specified by polygons just created
237  //----------------------------------------------
238  // Set the element area
239  double uniform_element_area=0.2;
240 
241  // Create a TriangleMeshClosedCurve object defining the outer boundary
243 
244  // Use the TriangleMeshParameters object for gathering all
245  // the necessary arguments for the TriangleMesh object
246  TriangleMeshParameters triangle_mesh_parameters(closed_curve_pt);
247 
248  // Define the maximum element area
249  triangle_mesh_parameters.element_area()=uniform_element_area;
250 
251  // Create the mesh
252  Solid_mesh_pt=new MESH(triangle_mesh_parameters);
253 
254  // Set error estimator for bulk mesh
255  Solid_mesh_pt->spatial_error_estimator_pt()=new Z2ErrorEstimator;
256 
257  // Choose error tolerances to force some uniform refinement
258  Solid_mesh_pt->min_permitted_error()=0.0001;
259  Solid_mesh_pt->max_permitted_error()=0.001;
260 
261  // Output boundaries
262  this->Solid_mesh_pt->output_boundaries("boundaries.dat");
263 
264  // Make the traction mesh
266 
267  // Add sub meshes
270 
271  // Build the global mesh
273 
274  // Call actions after adapt:
275  // 1) to build the traction elements
276  // 2) to pin the nodes on the lower boundary (boundary 3)
277  // 3) to complete the build of the elements
278  // Note there is slight duplication here because we rebuild the global mesh
279  // twice.
280  this->actions_after_adapt();
281 
282  // Setup equation numbering scheme
283  std::cout << "Number of equations: " << assign_eqn_numbers() << std::endl;
284 
285  // Set directory name
286  Doc_info.set_directory("RESLT");
287 
288  // Open trace file
289  char filename[100];
290  sprintf(filename,"%s/trace.dat",Doc_info.directory().c_str());
291  Trace_file.open(filename);
292 
293 } //end constructor
int i
Definition: BiCGSTAB_step_by_step.cpp:9
TriangleMeshPolygon * Outer_boundary_polyline_pt
Triangle mesh polygon for outer boundary.
Definition: adaptive_unstructured_two_d_solid.cc:151
DocInfo Doc_info
DocInfo object for output.
Definition: adaptive_unstructured_two_d_solid.cc:160
ofstream Trace_file
Trace file.
Definition: adaptive_unstructured_two_d_solid.cc:157
SolidMesh * Traction_mesh_pt
Pointer to mesh of traction elements.
Definition: adaptive_unstructured_two_d_solid.cc:148
void actions_after_adapt()
Add on the traction elements after adaptation.
Definition: adaptive_unstructured_two_d_solid.cc:316
bool Incompressible
Boolean flag used in an incompressible problem.
Definition: adaptive_unstructured_two_d_solid.cc:154
MESH * Solid_mesh_pt
Bulk mesh.
Definition: adaptive_unstructured_two_d_solid.cc:145
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
void set_directory(const std::string &directory)
Definition: oomph_utilities.cc:298
unsigned add_sub_mesh(Mesh *const &mesh_pt)
Definition: problem.h:1330
void build_global_mesh()
Definition: problem.cc:1493
unsigned long assign_eqn_numbers(const bool &assign_local_eqn_numbers=true)
Definition: problem.cc:1989
Definition: mesh.h:2562
Base class defining a closed curve for the Triangle mesh generation.
Definition: unstructured_two_d_mesh_geometry_base.h:1339
Definition: triangle_mesh.template.h:94
Class defining a polyline for use in Triangle Mesh generation.
Definition: unstructured_two_d_mesh_geometry_base.h:868
Class defining a closed polygon for the Triangle mesh generation.
Definition: unstructured_two_d_mesh_geometry_base.h:1451
Definition: oomph-lib/src/generic/Vector.h:58
Definition: error_estimator.h:266
string filename
Definition: MergeRestartFiles.py:39

References UnstructuredSolidProblem< ELEMENT, MESH >::actions_after_adapt(), oomph::Problem::add_sub_mesh(), oomph::Problem::assign_eqn_numbers(), oomph::Problem::build_global_mesh(), oomph::DocInfo::directory(), UnstructuredSolidProblem< ELEMENT, MESH >::Doc_info, oomph::TriangleMeshParameters::element_area(), MergeRestartFiles::filename, i, UnstructuredSolidProblem< ELEMENT, MESH >::Outer_boundary_polyline_pt, oomph::DocInfo::set_directory(), UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt, UnstructuredSolidProblem< ELEMENT, MESH >::Trace_file, and UnstructuredSolidProblem< ELEMENT, MESH >::Traction_mesh_pt.

◆ ~UnstructuredSolidProblem() [1/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

125 {}

◆ UnstructuredSolidProblem() [2/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [2/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

260 {}

◆ UnstructuredSolidProblem() [3/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [3/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

94 {}

◆ UnstructuredSolidProblem() [4/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [4/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

173 {}

◆ UnstructuredSolidProblem() [5/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [5/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

166 {}

◆ UnstructuredSolidProblem() [6/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [6/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

145 {}

◆ UnstructuredSolidProblem() [7/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem ( )

Constructor:

◆ ~UnstructuredSolidProblem() [7/7]

template<class ELEMENT , class MESH >
UnstructuredSolidProblem< ELEMENT, MESH >::~UnstructuredSolidProblem ( )
inline

Destructor (empty)

145 {}

Member Function Documentation

◆ actions_after_adapt() [1/2]

template<class ELEMENT >
void UnstructuredSolidProblem< ELEMENT >::actions_after_adapt
virtual

Add on the traction elements after adaptation.

Need to add on the traction elements after adaptation.

Reimplemented from oomph::Problem.

317 {
318  // The boundary in question is boundary 0
319  unsigned b=0;
320 
321  // How many bulk elements are adjacent to boundary b?
322  unsigned n_element=Solid_mesh_pt->nboundary_element(b);
323 
324  // Loop over the bulk elements adjacent to boundary b
325  for(unsigned e=0;e<n_element;e++)
326  {
327  // Get pointer to the bulk element that is adjacent to boundary b
328  ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
329  Solid_mesh_pt->boundary_element_pt(b,e));
330 
331  // Find the index of the face of element e along boundary b
332  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
333 
334  // Create solid traction element
336  new SolidTractionElement<ELEMENT>(bulk_elem_pt,face_index);
337 
338  // Add to mesh
340 
341  // Set the traction function
343  }
344 
345  // Now rebuild the global mesh
346  this->rebuild_global_mesh();
347 
348  // (Re)set the boundary conditions
349  // Pin both positions at lower boundary (boundary 3)
350  unsigned ibound=3;
351  unsigned num_nod= mesh_pt()->nboundary_node(ibound);
352  for (unsigned inod=0;inod<num_nod;inod++)
353  {
354  // Get node
355  SolidNode* nod_pt=Solid_mesh_pt->boundary_node_pt(ibound,inod);
356 
357  // Pin both directions
358  for (unsigned i=0;i<2;i++)
359  {
360  nod_pt->pin_position(i);
361  }
362  } // End of set boundary conditions
363 
364  // Pin the redundant solid pressures (if any)
366  Solid_mesh_pt->element_pt());
367 
368  // Complete the build of all elements so they are fully functional
369  n_element=Solid_mesh_pt->nelement();
370  for(unsigned e=0;e<n_element;e++)
371  {
372  // Cast to a solid element
373  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Solid_mesh_pt->element_pt(e));
374 
375  // Set the constitutive law
376  el_pt->constitutive_law_pt() =
378 
379  // Set the incompressibility flag if required
380  if(Incompressible)
381  {
382  // Need another dynamic cast
383  dynamic_cast<QPVDElementWithContinuousPressure<2>*>(el_pt)->
385  }
386  }
387 
388 } // end_actions_after_adapt
Array< double, 1, 3 > e(1./3., 0.5, 2.)
Scalar * b
Definition: benchVecAdd.cpp:17
void set_incompressible()
Set the problem to be incompressible.
Definition: adaptive_unstructured_two_d_solid.cc:128
unsigned long nboundary_node(const unsigned &ibound) const
Return number of nodes on a particular boundary.
Definition: mesh.h:833
void add_element_pt(GeneralisedElement *const &element_pt)
Add a (pointer to) an element to the mesh.
Definition: mesh.h:617
Definition: solid_elements.h:58
void rebuild_global_mesh()
Definition: problem.cc:1533
Mesh *& mesh_pt()
Return a pointer to the global mesh.
Definition: problem.h:1280
Definition: solid_elements.h:1523
Definition: nodes.h:1686
void pin_position(const unsigned &i)
Pin the nodal position.
Definition: nodes.h:1816
Definition: solid_traction_elements.h:78
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
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
ConstitutiveLaw * Constitutive_law_pt
Pointer to constitutive law.
Definition: TwenteMeshGluing.cpp:65

References b, Global_Physical_Variables::constant_pressure(), Global_Physical_Variables::Constitutive_law_pt, e(), i, oomph::SolidNode::pin_position(), and oomph::SolidTractionElement< ELEMENT >::traction_fct_pt.

Referenced by UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem().

◆ actions_after_adapt() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_after_adapt ( )
virtual

Add on the traction elements after adaptation.

Reimplemented from oomph::Problem.

◆ actions_after_newton_solve() [1/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_after_newton_solve ( )
inlinevirtual

Update the problem specs before solve: empty.

Reimplemented from oomph::Problem.

179 {}

◆ actions_after_newton_solve() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_after_newton_solve ( )
inlinevirtual

Update the problem specs before solve: empty.

Reimplemented from oomph::Problem.

151 {}

◆ actions_before_adapt() [1/2]

template<class ELEMENT >
void UnstructuredSolidProblem< ELEMENT >::actions_before_adapt
virtual

Remove Traction Mesh.

Actions before adapt: remove the traction elements in the surface mesh.

Reimplemented from oomph::Problem.

300 {
301  // How many surface elements are in the surface mesh
302  unsigned n_element = Traction_mesh_pt->nelement();
303 
304  // Loop over the surface elements and kill them
305  for(unsigned e=0;e<n_element;e++) {delete Traction_mesh_pt->element_pt(e);}
306 
307  // Wipe the mesh
309 
310 } // end_actions_before_adapt
void flush_element_and_node_storage()
Definition: mesh.h:407
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:448
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:590

References e().

◆ actions_before_adapt() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_before_adapt ( )
virtual

Remove Traction Mesh.

Reimplemented from oomph::Problem.

◆ actions_before_newton_solve() [1/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve: empty.

Reimplemented from oomph::Problem.

176 {}

◆ actions_before_newton_solve() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::actions_before_newton_solve ( )
inlinevirtual

Update the problem specs before solve: empty.

Reimplemented from oomph::Problem.

148 {}

◆ create_traction_elements() [1/2]

template<class ELEMENT >
void UnstructuredSolidProblem< ELEMENT >::create_traction_elements
private

Create traction elements.

298 {
299 
300  // Loop over traction boundaries
301  unsigned n=Solid_traction_boundary_id.size();
302  for (unsigned i=0;i<n;i++)
303  {
304  // Get boundary ID
305  unsigned b=Solid_traction_boundary_id[i];
306 
307  // How many bulk elements are adjacent to boundary b?
308  unsigned n_element = Solid_mesh_pt->nboundary_element(b);
309 
310  // Loop over the bulk elements adjacent to boundary b
311  for(unsigned e=0;e<n_element;e++)
312  {
313  // Get pointer to the bulk element that is adjacent to boundary b
314  ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(
315  Solid_mesh_pt->boundary_element_pt(b,e));
316 
317  //What is the index of the face of the element e along boundary b
318  int face_index = Solid_mesh_pt->face_index_at_boundary(b,e);
319 
320  // Create new element
322  new SolidTractionElement<ELEMENT>(bulk_elem_pt,face_index);
323 
324  // Add it to the mesh
325  Solid_traction_mesh_pt[i]->add_element_pt(el_pt);
326 
327  //Set the traction function
329  }
330  }
331 
332 } // end of create_traction_elements
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
Vector< SolidMesh * > Solid_traction_mesh_pt
Meshes of traction elements.
Definition: unstructured_three_d_solid/unstructured_three_d_solid.cc:159
Vector< unsigned > Solid_traction_boundary_id
IDs of solid mesh boundaries which make up the traction interface.
Definition: unstructured_three_d_solid/unstructured_three_d_solid.cc:165
void constant_pressure(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
Definition: unstructured_three_d_solid/unstructured_three_d_solid.cc:114

References b, Global_Parameters::constant_pressure(), e(), i, n, and oomph::SolidTractionElement< ELEMENT >::traction_fct_pt.

◆ create_traction_elements() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::create_traction_elements ( )
private

Create traction elements.

◆ doc_solution() [1/7]

template<class ELEMENT >
void UnstructuredSolidProblem< ELEMENT >::doc_solution

Doc the solution.

417 {
418 
419  ofstream some_file;
420  char filename[100];
421 
422  // Number of plot points
423  unsigned npts;
424  npts=2;
425 
426  // Output solution
427  //----------------
428  sprintf(filename,"%s/soln%i.dat",Doc_info.directory().c_str(),
429  Doc_info.number());
430  some_file.open(filename);
431  Solid_mesh_pt->output(some_file,npts);
432  some_file.close();
433 
434  // Output traction
435  //----------------
436  sprintf(filename,"%s/traction%i.dat",Doc_info.directory().c_str(),
437  Doc_info.number());
438  some_file.open(filename);
439  Traction_mesh_pt->output(some_file,npts);
440  some_file.close();
441 
442  // Output boundaries
443  //------------------
444  sprintf(filename,"%s/boundaries.dat",Doc_info.directory().c_str());
445  some_file.open(filename);
446  Solid_mesh_pt->output_boundaries(some_file);
447  some_file.close();
448 
449  // Write trace file: Norm values
450  //------------------------------
451  double norm=0.0;
452  Solid_mesh_pt->compute_norm(norm);
453  Trace_file << Global_Physical_Variables::P << " " << norm
454  << " " << get_strain_energy() << std::endl;
455 
456 }
double get_strain_energy()
Calculate the strain energy.
Definition: adaptive_unstructured_two_d_solid.cc:394
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
void output(std::ostream &outfile)
Output for all elements.
Definition: mesh.cc:2027
double P
Uniform pressure.
Definition: TwenteMeshGluing.cpp:77

References oomph::DocInfo::directory(), GlobalParameters::Doc_info, MergeRestartFiles::filename, oomph::DocInfo::number(), Global_Physical_Variables::P, and oomph::Problem_Parameter::Trace_file.

◆ doc_solution() [2/7]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution ( )

Doc the solution.

◆ doc_solution() [3/7]

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

Doc the solution.

271 {
272 
273  ofstream some_file;
274  char filename[100];
275 
276  // Number of plot points
277  unsigned npts;
278  npts=5;
279 
280  // Output solution
281  //----------------
282  sprintf(filename,"%s/soln%i.dat",doc_info.directory().c_str(),
283  doc_info.number());
284  some_file.open(filename);
285  Solid_mesh_pt->output(some_file,npts);
286  some_file.close();
287 
288  // Output traction
289  //----------------
290  sprintf(filename,"%s/traction%i.dat",doc_info.directory().c_str(),
291  doc_info.number());
292  some_file.open(filename);
293  Traction_mesh_pt->output(some_file,npts);
294  some_file.close();
295 
296  // Output boundaries
297  //------------------
298  sprintf(filename,"%s/boundaries.dat",doc_info.directory().c_str());
299  some_file.open(filename);
300  Solid_mesh_pt->output_boundaries(some_file);
301  some_file.close();
302 
303 }

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

◆ doc_solution() [4/7]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution ( DocInfo doc_info)

Doc the solution.

◆ doc_solution() [5/7]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution ( DocInfo doc_info)

Doc the solution.

◆ doc_solution() [6/7]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution ( DocInfo doc_info)

Doc the solution.

◆ doc_solution() [7/7]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::doc_solution ( DocInfo doc_info)

Doc the solution.

◆ get_strain_energy() [1/2]

template<class ELEMENT >
double UnstructuredSolidProblem< ELEMENT >::get_strain_energy

Calculate the strain energy.

Calculate the strain energy in the entire elastic solid.

395 {
396  double strain_energy=0.0;
397  const unsigned n_element = Solid_mesh_pt->nelement();
398  for(unsigned e=0;e<n_element;e++)
399  {
400  // Cast to a solid element
401  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(Solid_mesh_pt->element_pt(e));
402 
403  double pot_en;
404  double kin_en;
405  el_pt->get_energy(pot_en,kin_en);
406  strain_energy+=pot_en;
407  }
408 
409  return strain_energy;
410 } // end_get_strain_energy

References e().

◆ get_strain_energy() [2/2]

template<class ELEMENT , class MESH >
double UnstructuredSolidProblem< ELEMENT, MESH >::get_strain_energy ( )

Calculate the strain energy.

◆ set_incompressible() [1/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::set_incompressible ( )
inline

Set the problem to be incompressible.

128 {Incompressible=true;}

◆ set_incompressible() [2/2]

template<class ELEMENT , class MESH >
void UnstructuredSolidProblem< ELEMENT, MESH >::set_incompressible ( )
inline

Set the problem to be incompressible.

97 {Incompressible=true;}

Member Data Documentation

◆ Doc_info

template<class ELEMENT , class MESH >
DocInfo UnstructuredSolidProblem< ELEMENT, MESH >::Doc_info
private

◆ Incompressible

template<class ELEMENT , class MESH >
bool UnstructuredSolidProblem< ELEMENT, MESH >::Incompressible
private

Boolean flag used in an incompressible problem.

◆ Outer_boundary_polyline_pt

template<class ELEMENT , class MESH >
TriangleMeshPolygon * UnstructuredSolidProblem< ELEMENT, MESH >::Outer_boundary_polyline_pt
private

Triangle mesh polygon for outer boundary.

Referenced by UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem().

◆ Pinned_solid_boundary_id

template<class ELEMENT , class MESH >
Vector< unsigned > UnstructuredSolidProblem< ELEMENT, MESH >::Pinned_solid_boundary_id
private

IDs of solid mesh boundaries where displacements are pinned.

◆ Solid_mesh_pt [1/6]

template<class ELEMENT , class MESH >
MySolidTetgenMesh< ELEMENT > * UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

◆ Solid_mesh_pt [2/6]

template<class ELEMENT , class MESH >
ElasticQuadFromTriangleMesh<ELEMENT>* UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

Bulk mesh.

◆ Solid_mesh_pt [3/6]

template<class ELEMENT , class MESH >
RefineableSolidTriangleMesh<ELEMENT>* UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

Bulk mesh.

◆ Solid_mesh_pt [4/6]

template<class ELEMENT , class MESH >
ElasticTetMesh<ELEMENT>* UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

Bulk mesh.

◆ Solid_mesh_pt [5/6]

template<class ELEMENT , class MESH >
ElasticTriangleMesh<ELEMENT>* UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

Bulk mesh.

◆ Solid_mesh_pt [6/6]

template<class ELEMENT , class MESH >
MySolidTetgenMesh<ELEMENT>* UnstructuredSolidProblem< ELEMENT, MESH >::Solid_mesh_pt
private

Bulk solid mesh.

◆ Solid_traction_boundary_id

template<class ELEMENT , class MESH >
Vector< unsigned > UnstructuredSolidProblem< ELEMENT, MESH >::Solid_traction_boundary_id
private

IDs of solid mesh boundaries which make up the traction interface.

◆ Solid_traction_mesh_pt

template<class ELEMENT , class MESH >
Vector< SolidMesh * > UnstructuredSolidProblem< ELEMENT, MESH >::Solid_traction_mesh_pt
private

Meshes of traction elements.

◆ Trace_file

template<class ELEMENT , class MESH >
ofstream UnstructuredSolidProblem< ELEMENT, MESH >::Trace_file
private

◆ Traction_mesh_pt

template<class ELEMENT , class MESH >
SolidMesh * UnstructuredSolidProblem< ELEMENT, MESH >::Traction_mesh_pt
private

Pointer to mesh of traction elements.

Referenced by UnstructuredSolidProblem< ELEMENT, MESH >::UnstructuredSolidProblem().


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