Public Member Functions | Private Member Functions | Private Attributes | List of all members
RefineableFishPoissonProblem< ELEMENT > Class Template Reference
+ Inheritance diagram for RefineableFishPoissonProblem< ELEMENT >:

Public Member Functions

 RefineableFishPoissonProblem (const bool &fix_position, const string &directory_name, const unsigned &i_case)
 
virtual ~RefineableFishPoissonProblem ()
 Destructor. More...
 
void actions_before_newton_convergence_check ()
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve: Update mesh. More...
 
AlgebraicRefineableFishMesh< ELEMENT > * fish_mesh_pt ()
 
double & load ()
 Return value of the "load" on the elastically supported ring. More...
 
double & y_c ()
 
void doc_solution ()
 Doc the solution. More...
 
DocInfo & doc_info ()
 Access to DocInfo object. More...
 
 RefineableFishPoissonProblem (bool fix_position, string directory_name)
 
virtual ~RefineableFishPoissonProblem ()
 Destructor. More...
 
void actions_before_newton_convergence_check ()
 
void actions_before_newton_solve ()
 Update the problem specs before solve: Update nodal positions. More...
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
MacroElementNodeUpdateRefineableFishMesh< ELEMENT > * fish_mesh_pt ()
 
double & load ()
 
double & y_c ()
 
void doc_solution ()
 Doc the solution. More...
 
DocInfo & doc_info ()
 Access to DocInfo object. More...
 
 RefineableFishPoissonProblem ()
 Constructor. More...
 
virtual ~RefineableFishPoissonProblem ()
 Destructor: Empty; all memory gets cleaned up in base destructor. More...
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs befor solve (also empty) More...
 
void actions_before_adapt ()
 Actions before adapt (essentially empty) More...
 
RefineableFishMesh< ELEMENT > * mesh_pt ()
 
void doc_solution (DocInfo &doc_info)
 Doc the solution in tecplot format. More...
 
 RefineableFishPoissonProblem (const bool &fix_position, string directory_name)
 
virtual ~RefineableFishPoissonProblem ()
 Destructor. More...
 
void actions_before_newton_convergence_check ()
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve: Update mesh. More...
 
AlgebraicRefineableFishMesh< ELEMENT > * fish_mesh_pt ()
 
double & load ()
 Return value of the "load" on the elastically supported ring. More...
 
void doc_solution ()
 Doc the solution. More...
 
DocInfo & doc_info ()
 Access to DocInfo object. More...
 
 RefineableFishPoissonProblem ()
 Constructor. More...
 
virtual ~RefineableFishPoissonProblem ()
 Destructor: Empty. More...
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
RefineableFishMesh< ELEMENT > * mesh_pt ()
 
void doc_solution (DocInfo &doc_info)
 
 RefineableFishPoissonProblem ()
 Constructor. More...
 
virtual ~RefineableFishPoissonProblem ()
 Destructor: Empty. More...
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
RefineableFishMesh< ELEMENT > * mesh_pt ()
 
void doc_solution (DocInfo &doc_info)
 
 RefineableFishPoissonProblem ()
 Constructor. More...
 
virtual ~RefineableFishPoissonProblem ()
 Destructor: Empty. More...
 
void actions_after_newton_solve ()
 Update the problem specs after solve (empty) More...
 
void actions_before_newton_solve ()
 Update the problem specs before solve (empty) More...
 
RefineableFishMesh< ELEMENT > * mesh_pt ()
 
void doc_solution (DocInfo &doc_info)
 
- 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_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 set_shape_deriv_method ()
 Helper fct to set method for evaluation of shape derivs. More...
 

Private Attributes

Node * Doc_node_pt
 Node at which the solution of the Poisson equation is documented. More...
 
ofstream Trace_file
 Trace file. More...
 
AlgebraicRefineableFishMesh< ELEMENT > * Fish_mesh_pt
 Pointer to fish mesh. More...
 
Mesh * Fish_back_mesh_pt
 
Data * Load_pt
 Pointer to data item that stores the "load" on the fish back. More...
 
bool Fix_position
 Is the position of the fish back prescribed? More...
 
DocInfo Doc_info
 Doc info object. More...
 
unsigned Case_id
 Case id. More...
 
MacroElementNodeUpdateRefineableFishMesh< ELEMENT > * Fish_mesh_pt
 Pointer to fish 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_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 RefineableFishPoissonProblem< ELEMENT >

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Refineable Poisson problem in deformable fish-shaped domain. Template parameter identify the elements.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Refineable Poisson problem in deformable fish-shaped domain. Template parameter identifies the element.

Refineable Poisson problem in fish-shaped domain. Template parameter identifies the element type.

Constructor & Destructor Documentation

◆ RefineableFishPoissonProblem() [1/7]

template<class ELEMENT >
RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem ( const bool &  fix_position,
const string &  directory_name,
const unsigned &  i_case 
)

Constructor: Bool flag specifies if position of fish back is prescribed or computed from the coupled problem. String specifies output directory.

Constructor for adaptive Poisson problem in deformable fish-shaped domain. Pass flag if position of fish back is fixed, and the output directory.

Loop over elements and set pointers to source function

242  : Fix_position(fix_position), Case_id(i_case)
243 {
244 
245 
246  // Set output directory
247  Doc_info.set_directory(directory_name);
248 
249  // Initialise step number
250  Doc_info.number()=0;
251 
252  // Open trace file
253  char filename[100];
254  sprintf(filename,"%s/trace.dat",directory_name.c_str());
255  Trace_file.open(filename);
256 
257  Trace_file
258  << "VARIABLES=\"load\",\"y<sub>circle</sub>\",\"u<sub>control</sub>\""
259  << std::endl;
260 
261  // Set coordinates and radius for the circle that will become the fish back
262  double x_c=0.5;
263  double y_c=0.0;
264  double r_back=1.0;
265 
266  // Build geometric element that will become the fish back
267  GeomObject* fish_back_pt=new ElasticallySupportedRingElement(x_c,y_c,r_back);
268 
269  // Build fish mesh with geometric object that specifies the fish back
270  Fish_mesh_pt=new AlgebraicRefineableFishMesh<ELEMENT>(fish_back_pt);
271 
272  // Add the fish mesh to the problem's collection of submeshes:
273  add_sub_mesh(Fish_mesh_pt);
274 
275  // Build mesh that will store only the geometric wall element
276  Fish_back_mesh_pt=new Mesh;
277 
278  // So far, the mesh is completely empty. Let's add the
279  // one (and only!) GeneralisedElement which represents the shape
280  // of the fish's back to it:
281  Fish_back_mesh_pt->add_element_pt(dynamic_cast<GeneralisedElement*>(
282  Fish_mesh_pt->fish_back_pt()));
283 
284  // Add the fish back mesh to the problem's collection of submeshes:
285  add_sub_mesh(Fish_back_mesh_pt);
286 
287  // Now build global mesh from the submeshes
288  build_global_mesh();
289 
290 
291  // Create/set error estimator
292  fish_mesh_pt()->spatial_error_estimator_pt()=new Z2ErrorEstimator;
293 
294  // Choose a node at which the solution is documented: Choose
295  // the central node that is shared by all four elements in
296  // the base mesh because it exists at all refinement levels.
297 
298  // How many nodes does element 0 have?
299  unsigned nnod=fish_mesh_pt()->finite_element_pt(0)->nnode();
300 
301  // The central node is the last node in element 0:
302  Doc_node_pt=fish_mesh_pt()->finite_element_pt(0)->node_pt(nnod-1);
303 
304  // Doc
305  cout << std::endl << "Control node is located at: "
306  << Doc_node_pt->x(0) << " " << Doc_node_pt->x(1)
307  << std::endl << std::endl;
308 
309  // Position of fish back is prescribed
310  if (Fix_position)
311  {
312  // Create the load data object
313  Load_pt=new Data(1);
314 
315  // Pin the prescribed load
316  Load_pt->pin(0);
317 
318  // Pin the vertical displacement
319  dynamic_cast<ElasticallySupportedRingElement*>(
320  Fish_mesh_pt->fish_back_pt())->pin_yc();
321  }
322  // Coupled problem: The position of the fish back is determined
323  // via the solution of the Poisson equation: The solution at
324  // the control node acts as the load for the displacement of the
325  // fish back
326  else
327  {
328  // Use the solution (value 0) at the control node as the load
329  // that acts on the ring. [Note: Node == Data by inheritance]
330  Load_pt=Doc_node_pt;
331  }
332 
333 
334  // Set the pointer to the Data object that specifies the
335  // load on the fish's back
336  dynamic_cast<ElasticallySupportedRingElement*>(Fish_mesh_pt->fish_back_pt())->
337  set_load_pt(Load_pt);
338 
339 
340  // Set the boundary conditions for this problem: All nodes are
341  // free by default -- just pin the ones that have Dirichlet conditions
342  // here.
343  unsigned num_bound = fish_mesh_pt()->nboundary();
344  for(unsigned ibound=0;ibound<num_bound;ibound++)
345  {
346  unsigned num_nod= fish_mesh_pt()->nboundary_node(ibound);
347  for (unsigned inod=0;inod<num_nod;inod++)
348  {
349  fish_mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
350  }
351  }
352 
353 
354  // Set homogeneous boundary conditions on all boundaries
355  for(unsigned ibound=0;ibound<num_bound;ibound++)
356  {
357  // Loop over the nodes on boundary
358  unsigned num_nod=fish_mesh_pt()->nboundary_node(ibound);
359  for (unsigned inod=0;inod<num_nod;inod++)
360  {
361  fish_mesh_pt()->boundary_node_pt(ibound,inod)->set_value(0,0.0);
362  }
363  }
364 
366  unsigned n_element = fish_mesh_pt()->nelement();
367  for(unsigned i=0;i<n_element;i++)
368  {
369  // Upcast from FiniteElement to the present element
370  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fish_mesh_pt()->element_pt(i));
371 
372  //Set the source function pointer
373  el_pt->source_fct_pt() = &ConstSourceForPoisson::get_source;
374  }
375 
376  // Set shape derivative method
377  set_shape_deriv_method();
378 
379  // Do equation numbering
380  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
381 
382 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
RefineableFishPoissonProblem::set_shape_deriv_method
void set_shape_deriv_method()
Helper fct to set method for evaluation of shape derivs.
Definition: algebraic_free_boundary_poisson.cc:141
RefineableFishPoissonProblem::y_c
double & y_c()
Definition: algebraic_free_boundary_poisson.cc:126
RefineableFishPoissonProblem::Fix_position
bool Fix_position
Is the position of the fish back prescribed?
Definition: algebraic_free_boundary_poisson.cc:220
RefineableFishPoissonProblem::Doc_node_pt
Node * Doc_node_pt
Node at which the solution of the Poisson equation is documented.
Definition: algebraic_free_boundary_poisson.cc:204
RefineableFishPoissonProblem::fish_mesh_pt
AlgebraicRefineableFishMesh< ELEMENT > * fish_mesh_pt()
Definition: algebraic_free_boundary_poisson.cc:112
RefineableFishPoissonProblem::Fish_mesh_pt
AlgebraicRefineableFishMesh< ELEMENT > * Fish_mesh_pt
Pointer to fish mesh.
Definition: algebraic_free_boundary_poisson.cc:210
RefineableFishPoissonProblem::Load_pt
Data * Load_pt
Pointer to data item that stores the "load" on the fish back.
Definition: algebraic_free_boundary_poisson.cc:217
RefineableFishPoissonProblem::Trace_file
ofstream Trace_file
Trace file.
Definition: algebraic_free_boundary_poisson.cc:207
RefineableFishPoissonProblem::Fish_back_mesh_pt
Mesh * Fish_back_mesh_pt
Definition: algebraic_free_boundary_poisson.cc:214
RefineableFishPoissonProblem::Doc_info
DocInfo Doc_info
Doc info object.
Definition: algebraic_free_boundary_poisson.cc:223
RefineableFishPoissonProblem::Case_id
unsigned Case_id
Case id.
Definition: algebraic_free_boundary_poisson.cc:226
oomph::AlgebraicRefineableFishMesh
Refineable fish shaped mesh with algebraic node update function.
Definition: fish_mesh.template.h:491
oomph::Data
Definition: nodes.h:86
oomph::Data::pin
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:385
oomph::DocInfo::set_directory
void set_directory(const std::string &directory)
Definition: oomph_utilities.cc:298
oomph::DocInfo::number
unsigned & number()
Number used (e.g.) for labeling output files.
Definition: oomph_utilities.h:554
oomph::ElasticallySupportedRingElement
Definition: circle_as_generalised_element.h:57
oomph::GeneralisedElement
Definition: elements.h:73
oomph::GeomObject
Definition: geom_objects.h:101
oomph::Mesh
Definition: mesh.h:67
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::Node::x
double & x(const unsigned &i)
Return the i-th nodal coordinate.
Definition: nodes.h:1060
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::Z2ErrorEstimator
Definition: error_estimator.h:266
ConstSourceForPoisson::get_source
void get_source(const Vector< double > &x, double &source)
Const source function.
Definition: algebraic_free_boundary_poisson.cc:61
MergeRestartFiles.filename
string filename
Definition: MergeRestartFiles.py:39

References oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::Problem::assign_eqn_numbers(), oomph::Problem::build_global_mesh(), RefineableFishPoissonProblem< ELEMENT >::Doc_info, RefineableFishPoissonProblem< ELEMENT >::Doc_node_pt, MergeRestartFiles::filename, RefineableFishPoissonProblem< ELEMENT >::Fish_back_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt(), RefineableFishPoissonProblem< ELEMENT >::Fish_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::Fix_position, ConstSourceForPoisson::get_source(), i, RefineableFishPoissonProblem< ELEMENT >::Load_pt, oomph::DocInfo::number(), oomph::Data::pin(), oomph::DocInfo::set_directory(), RefineableFishPoissonProblem< ELEMENT >::set_shape_deriv_method(), RefineableFishPoissonProblem< ELEMENT >::Trace_file, oomph::Node::x(), and RefineableFishPoissonProblem< ELEMENT >::y_c().

◆ ~RefineableFishPoissonProblem() [1/7]

template<class ELEMENT >
RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem
virtual

Destructor.

Destructor for Poisson problem in deformable fish-shaped domain.

391 {
392  // Close trace file
393  Trace_file.close();
394 
395 }

References oomph::Problem_Parameter::Trace_file.

◆ RefineableFishPoissonProblem() [2/7]

template<class ELEMENT >
RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem ( bool  fix_position,
string  directory_name 
)

Constructor: Bool flag specifies if position of fish back is prescribed or computed from the coupled problem. String specifies output directory

Constructor for adaptive Poisson problem in deformable fish-shaped domain. Pass flag if position of fish back is fixed, and the output directory.

Loop over elements and set pointers to source function

181  : Fix_position(fix_position)
182 {
183 
184  // Set output directory
185  Doc_info.set_directory(directory_name);
186 
187  // Initialise step number
188  Doc_info.number()=0;
189 
190  // Open trace file
191  char filename[100];
192  sprintf(filename,"%s/trace.dat",directory_name.c_str());
193  Trace_file.open(filename);
194  Trace_file
195  << "VARIABLES=\"load\",\"y<sub>circle</sub>\",\"u<sub>control</sub>\""
196  << std::endl;
197 
198  // Set coordinates and radius for the circle that will become the fish back
199  double x_c=0.5;
200  double y_c=0.0;
201  double r_back=1.0;
202 
203  // Build geometric object that will become the fish back
204  GeomObject* fish_back_pt=new ElasticallySupportedRingElement(x_c,y_c,r_back);
205 
206  // Build fish mesh with geometric object that specifies the fish back
207  Fish_mesh_pt=new MacroElementNodeUpdateRefineableFishMesh<ELEMENT>(fish_back_pt);
208 
209  // Add the fish mesh to the problem's collection of submeshes:
210  add_sub_mesh(Fish_mesh_pt);
211 
212  // Build mesh that will store only the geometric wall element
213  Fish_back_mesh_pt=new Mesh;
214 
215  // So far, the mesh is completely empty. Let's add the
216  // one (and only!) GeneralisedElement which represents the shape
217  // of the fish's back to it:
218  Fish_back_mesh_pt->add_element_pt(dynamic_cast<GeneralisedElement*>(
219  Fish_mesh_pt->fish_back_pt()));
220 
221  // Add the fish back mesh to the problem's collection of submeshes:
222  add_sub_mesh(Fish_back_mesh_pt);
223 
224  // Now build global mesh from the submeshes
225  build_global_mesh();
226 
227  // Create/set error estimator
228  fish_mesh_pt()->spatial_error_estimator_pt()=new Z2ErrorEstimator;
229 
230 
231  // Choose a node at which the solution is documented: Choose
232  // the central node that is shared by all four elements in
233  // the base mesh because it exists at all refinement levels.
234 
235  // How many nodes does element 0 have?
236  unsigned nnod=fish_mesh_pt()->finite_element_pt(0)->nnode();
237 
238  // The central node is the last node in element 0:
239  Doc_node_pt=fish_mesh_pt()->finite_element_pt(0)->node_pt(nnod-1);
240 
241  // Doc
242  cout << std::endl << "Control node is located at: "
243  << Doc_node_pt->x(0) << " " << Doc_node_pt->x(1) << std::endl << std::endl;
244 
245  // Position of fish back is prescribed
246  if (Fix_position)
247  {
248  // Create the load data object
249  Load_pt=new Data(1);
250 
251  // Pin the prescribed load
252  Load_pt->pin(0);
253 
254  // Pin the vertical displacement
255  dynamic_cast<ElasticallySupportedRingElement*>(
256  Fish_mesh_pt->fish_back_pt())->pin_yc();
257 
258  }
259  // Coupled problem: The position of the fish back is determined
260  // via the solution of the Poisson equation: The solution at
261  // the control node acts as the load for the displacement of the
262  // fish back
263  else
264  {
265  // Use the solution (value 0) at the control node as the load
266  // that acts on the ring. [Note: Node == Data by inheritance]
267  Load_pt=Doc_node_pt;
268  }
269 
270 
271  // Set the pointer to the Data object that specifies the
272  // load on the fish's back
273  dynamic_cast<ElasticallySupportedRingElement*>(Fish_mesh_pt->fish_back_pt())->
274  set_load_pt(Load_pt);
275 
276 
277  // Set the boundary conditions for this problem: All nodes are
278  // free by default -- just pin the ones that have Dirichlet conditions
279  // here.
280  unsigned num_bound = fish_mesh_pt()->nboundary();
281  for(unsigned ibound=0;ibound<num_bound;ibound++)
282  {
283  unsigned num_nod= fish_mesh_pt()->nboundary_node(ibound);
284  for (unsigned inod=0;inod<num_nod;inod++)
285  {
286  fish_mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
287  }
288  }
289 
290 
291  // Set homogeneous boundary conditions on all boundaries
292  for(unsigned ibound=0;ibound<num_bound;ibound++)
293  {
294  // Loop over the nodes on boundary
295  unsigned num_nod=fish_mesh_pt()->nboundary_node(ibound);
296  for (unsigned inod=0;inod<num_nod;inod++)
297  {
298  fish_mesh_pt()->boundary_node_pt(ibound,inod)->set_value(0,0.0);
299  }
300  }
301 
303  unsigned n_element = fish_mesh_pt()->nelement();
304  for(unsigned i=0;i<n_element;i++)
305  {
306  // Upcast from FiniteElement to the present element
307  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fish_mesh_pt()->element_pt(i));
308 
309  //Set the source function pointer
310  el_pt->source_fct_pt() = &ConstSourceForPoisson::get_source;
311  }
312 
313  // Do equation numbering
314  cout << "Number of equations: " << assign_eqn_numbers() << std::endl;
315 
316 }
oomph::MacroElementNodeUpdateRefineableFishMesh
Definition: fish_mesh.template.h:200

References oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::Problem::assign_eqn_numbers(), oomph::Problem::build_global_mesh(), RefineableFishPoissonProblem< ELEMENT >::Doc_info, RefineableFishPoissonProblem< ELEMENT >::Doc_node_pt, MergeRestartFiles::filename, RefineableFishPoissonProblem< ELEMENT >::Fish_back_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt(), RefineableFishPoissonProblem< ELEMENT >::Fish_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::Fix_position, ConstSourceForPoisson::get_source(), i, RefineableFishPoissonProblem< ELEMENT >::Load_pt, oomph::DocInfo::number(), oomph::Data::pin(), oomph::DocInfo::set_directory(), RefineableFishPoissonProblem< ELEMENT >::Trace_file, oomph::Node::x(), and RefineableFishPoissonProblem< ELEMENT >::y_c().

◆ ~RefineableFishPoissonProblem() [2/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
virtual

Destructor.

◆ RefineableFishPoissonProblem() [3/7]

template<class ELEMENT >
RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem

Constructor.

Constructor for adaptive Poisson problem in fish-shaped domain.

113 {
114 
115  // Build fish mesh -- this is a coarse base mesh consisting
116  // of four elements. We'll refine/adapt the mesh later.
117  Problem::mesh_pt()=new RefineableFishMesh<ELEMENT>;
118 
119  // Create/set error estimator
120  mesh_pt()->spatial_error_estimator_pt()=new Z2ErrorEstimator;
121 
122  // Set the boundary conditions for this problem: All nodes are
123  // free by default -- just pin the ones that have Dirichlet conditions
124  // here. Since the boundary values are never changed, we set
125  // them here rather than in actions_before_solve().
126  unsigned n_bound = mesh_pt()->nboundary();
127  for(unsigned i=0;i<n_bound;i++)
128  {
129  unsigned n_node = mesh_pt()->nboundary_node(i);
130  for (unsigned n=0;n<n_node;n++)
131  {
132  // Pin the single scalar value at this node
133  mesh_pt()->boundary_node_pt(i,n)->pin(0);
134 
135  // Assign the homogenous boundary condition for the one and only
136  // nodal value
137  mesh_pt()->boundary_node_pt(i,n)->set_value(0,0.0);
138  }
139  }
140 
141  // Loop over elements and set pointers to source function
142  unsigned n_element = mesh_pt()->nelement();
143  for(unsigned e=0;e<n_element;e++)
144  {
145  // Upcast from FiniteElement to the present element
146  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(mesh_pt()->element_pt(e));
147 
148  //Set the source function pointer
149  el_pt->source_fct_pt() = &ConstSourceForPoisson::source_function;
150  }
151 
152  // Setup the equation numbering scheme
153  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
154 
155 } // end of constructor
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
RefineableFishPoissonProblem::mesh_pt
RefineableFishMesh< ELEMENT > * mesh_pt()
Definition: mpi/distribution/fish_poisson/fish_poisson.cc:92
oomph::RefineableFishMesh
Definition: fish_mesh.template.h:129
ConstSourceForPoisson::source_function
void source_function(const Vector< double > &x, double &source)
Const source function.
Definition: mpi/distribution/fish_poisson/fish_poisson.cc:54

References e(), i, n, ConstSourceForPoisson::source_function(), and oomph::RefineableMeshBase::spatial_error_estimator_pt().

◆ ~RefineableFishPoissonProblem() [3/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
inlinevirtual

Destructor: Empty; all memory gets cleaned up in base destructor.

78 {};

◆ RefineableFishPoissonProblem() [4/7]

template<class ELEMENT >
RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem ( const bool &  fix_position,
string  directory_name 
)

Constructor: Bool flag specifies if position of fish back is prescribed or computed from the coupled problem. String specifies output directory

Constructor for adaptive Poisson problem in deformable fish-shaped domain. Pass flag if position of fish back is fixed, and the output directory.

Loop over elements and set pointers to source function

327  : Fix_position(fix_position)
328 {
329 
330  // Set output directory
331  Doc_info.set_directory(directory_name);
332 
333  // Initialise step number
334  Doc_info.number()=0;
335 
336  // Open trace file
337  char filename[100];
338  sprintf(filename,"%s/trace.dat",directory_name.c_str());
339  Trace_file.open(filename);
340 
341  Trace_file
342  << "VARIABLES=\"load\",\"y<sub>circle</sub>\",\"u<sub>control</sub>\""
343  << std::endl;
344 
345  // Set coordinates and radius for the circle that will become the fish back
346  double x_c=0.5;
347  double y_c=0.0;
348  double r_back=1.0;
349 
350  // Build geometric element that will become the fish back
351  GeomObject* fish_back_pt=new ElasticFishBackElement(x_c,y_c,r_back);
352 
353  // Build fish mesh with geometric object that specifies the fish back
354  Fish_mesh_pt=new AlgebraicRefineableFishMesh<ELEMENT>(fish_back_pt);
355 
356  // Add the fish mesh to the problem's collection of submeshes:
357  add_sub_mesh(Fish_mesh_pt);
358 
359  // Build mesh that will store only the geometric wall element
360  Fish_back_mesh_pt=new Mesh;
361 
362  // So far, the mesh is completely empty. Let's add the
363  // one (and only!) GeneralisedElement which represents the shape
364  // of the fish's back to it:
365  Fish_back_mesh_pt->add_element_pt(dynamic_cast<GeneralisedElement*>(
366  Fish_mesh_pt->fish_back_pt()));
367 
368  // Add the fish back mesh to the problem's collection of submeshes:
369  add_sub_mesh(Fish_back_mesh_pt);
370 
371  // Now build global mesh from the submeshes
372  build_global_mesh();
373 
374 
375  // Create/set error estimator
376  fish_mesh_pt()->spatial_error_estimator_pt()=new Z2ErrorEstimator;
377 
378  // Choose a node at which the solution is documented: Choose
379  // the central node that is shared by all four elements in
380  // the base mesh because it exists at all refinement levels.
381 
382  // How many nodes does element 0 have?
383  unsigned nnod=fish_mesh_pt()->finite_element_pt(0)->nnode();
384 
385  // The central node is the last node in element 0:
386  Doc_node_pt=fish_mesh_pt()->finite_element_pt(0)->node_pt(nnod-1);
387 
388  // Doc
389  cout << std::endl << "Control node is located at: "
390  << Doc_node_pt->x(0) << " " << Doc_node_pt->x(1) << std::endl << std::endl;
391 
392 
393 
394  // Position of fish back is prescribed
395  if (Fix_position)
396  {
397  // Create the prescribed position data
398  Load_pt=new Data(1);
399 
400  // Pin the prescribed position
401  Load_pt->pin(0);
402  }
403  // Coupled problem: The position of the fish back is determined
404  // via the solution of the Poisson equation: The solution at
405  // the control node acts as the load for the displacement of the
406  // fish back
407  else
408  {
409  // Use the solution (value 0) at the control node as the load
410  // that acts on the ring. [Note: Node == Data by inheritance]
411  Load_pt=Doc_node_pt;
412  }
413 
414 
415  // Set the pointer to the Data object that specifies the
416  // load on the fish's back
417  dynamic_cast<ElasticFishBackElement*>(Fish_mesh_pt->fish_back_pt())->
418  set_load_pt(Load_pt);
419 
420 
421  // Set the boundary conditions for this problem: All nodes are
422  // free by default -- just pin the ones that have Dirichlet conditions
423  // here.
424  unsigned num_bound = fish_mesh_pt()->nboundary();
425  for(unsigned ibound=0;ibound<num_bound;ibound++)
426  {
427  unsigned num_nod= fish_mesh_pt()->nboundary_node(ibound);
428  for (unsigned inod=0;inod<num_nod;inod++)
429  {
430  fish_mesh_pt()->boundary_node_pt(ibound,inod)->pin(0);
431  }
432  }
433 
434 
435  // Set homogeneous boundary conditions on all boundaries
436  for(unsigned ibound=0;ibound<num_bound;ibound++)
437  {
438  // Loop over the nodes on boundary
439  unsigned num_nod=fish_mesh_pt()->nboundary_node(ibound);
440  for (unsigned inod=0;inod<num_nod;inod++)
441  {
442  fish_mesh_pt()->boundary_node_pt(ibound,inod)->set_value(0,0.0);
443  }
444  }
445 
447  unsigned n_element = fish_mesh_pt()->nelement();
448  for(unsigned i=0;i<n_element;i++)
449  {
450  // Upcast from FiniteElement to the present element
451  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fish_mesh_pt()->element_pt(i));
452 
453  //Set the source function pointer
454  el_pt->source_fct_pt() = &ConstSourceForPoisson::get_source;
455  }
456 
457  //Attach the boundary conditions to the mesh
458  cout <<"Number of equations: " << assign_eqn_numbers() << std::endl;
459 
460 }
ElasticFishBackElement
Definition: poisson/elastic_poisson/elastic_poisson.cc:88

References oomph::Mesh::add_element_pt(), oomph::Problem::add_sub_mesh(), oomph::Problem::assign_eqn_numbers(), oomph::Problem::build_global_mesh(), RefineableFishPoissonProblem< ELEMENT >::Doc_info, RefineableFishPoissonProblem< ELEMENT >::Doc_node_pt, MergeRestartFiles::filename, RefineableFishPoissonProblem< ELEMENT >::Fish_back_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt(), RefineableFishPoissonProblem< ELEMENT >::Fish_mesh_pt, RefineableFishPoissonProblem< ELEMENT >::Fix_position, ConstSourceForPoisson::get_source(), i, RefineableFishPoissonProblem< ELEMENT >::Load_pt, oomph::DocInfo::number(), oomph::Data::pin(), oomph::DocInfo::set_directory(), RefineableFishPoissonProblem< ELEMENT >::Trace_file, oomph::Node::x(), and RefineableFishPoissonProblem< ELEMENT >::y_c().

◆ ~RefineableFishPoissonProblem() [4/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
virtual

Destructor.

◆ RefineableFishPoissonProblem() [5/7]

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

Constructor.

◆ ~RefineableFishPoissonProblem() [5/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
inlinevirtual

Destructor: Empty.

78 {}

◆ RefineableFishPoissonProblem() [6/7]

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

Constructor.

◆ ~RefineableFishPoissonProblem() [6/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
inlinevirtual

Destructor: Empty.

76 {}

◆ RefineableFishPoissonProblem() [7/7]

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

Constructor.

◆ ~RefineableFishPoissonProblem() [7/7]

template<class ELEMENT >
virtual RefineableFishPoissonProblem< ELEMENT >::~RefineableFishPoissonProblem ( )
inlinevirtual

Destructor: Empty.

76 {}

Member Function Documentation

◆ actions_after_newton_solve() [1/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

103 {}

◆ actions_after_newton_solve() [2/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

113 {}

◆ actions_after_newton_solve() [3/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

81 {}

◆ actions_after_newton_solve() [4/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

264 {}

◆ actions_after_newton_solve() [5/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

81 {}

◆ actions_after_newton_solve() [6/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

79 {}

◆ actions_after_newton_solve() [7/7]

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

Update the problem specs after solve (empty)

Reimplemented from oomph::Problem.

79 {}

◆ actions_before_adapt()

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::actions_before_adapt ( )
inlinevirtual

Actions before adapt (essentially empty)

Reimplemented from oomph::Problem.

87 {oomph_info << "Min/max about to adapt\n";}
oomph::oomph_info
OomphInfo oomph_info
Definition: oomph_definitions.cc:319

References oomph::oomph_info.

◆ actions_before_newton_convergence_check() [1/3]

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update after Newton step: Update mesh in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

98  {
99  fish_mesh_pt()->node_update();
100  }

◆ actions_before_newton_convergence_check() [2/3]

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update after Newton step: Update in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

101  {
102  fish_mesh_pt()->node_update();
103  }

◆ actions_before_newton_convergence_check() [3/3]

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::actions_before_newton_convergence_check ( )
inlinevirtual

Update after Newton step: Update mesh in response to possible changes in the wall shape

Reimplemented from oomph::Problem.

259  {
260  fish_mesh_pt()->node_update();
261  }

◆ actions_before_newton_solve() [1/7]

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

Update the problem specs before solve: Update mesh.

Reimplemented from oomph::Problem.

107  {
108  fish_mesh_pt()->node_update();
109  }

◆ actions_before_newton_solve() [2/7]

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

Update the problem specs before solve: Update nodal positions.

Reimplemented from oomph::Problem.

108  {
109  fish_mesh_pt()->node_update();
110  }

◆ actions_before_newton_solve() [3/7]

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

Update the problem specs befor solve (also empty)

Reimplemented from oomph::Problem.

84 {}

◆ actions_before_newton_solve() [4/7]

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

Update the problem specs before solve: Update mesh.

Reimplemented from oomph::Problem.

268  {
269  fish_mesh_pt()->node_update();
270  }

◆ actions_before_newton_solve() [5/7]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

84 {}

◆ actions_before_newton_solve() [6/7]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

82 {}

◆ actions_before_newton_solve() [7/7]

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

Update the problem specs before solve (empty)

Reimplemented from oomph::Problem.

82 {}

◆ doc_info() [1/3]

template<class ELEMENT >
DocInfo& RefineableFishPoissonProblem< ELEMENT >::doc_info ( )
inline

Access to DocInfo object.

136 {return Doc_info;}

References GlobalParameters::Doc_info.

◆ doc_info() [2/3]

template<class ELEMENT >
DocInfo& RefineableFishPoissonProblem< ELEMENT >::doc_info ( )
inline

Access to DocInfo object.

140 {return Doc_info;}

References GlobalParameters::Doc_info.

◆ doc_info() [3/3]

template<class ELEMENT >
DocInfo& RefineableFishPoissonProblem< ELEMENT >::doc_info ( )
inline

Access to DocInfo object.

288 {return Doc_info;}

References GlobalParameters::Doc_info.

◆ doc_solution() [1/7]

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

Doc the solution.

Doc the solution in tecplot format.

405 {
406 
407  ofstream some_file;
408  char filename[100];
409 
410  // Number of plot points in each coordinate direction.
411  unsigned npts;
412  npts=5;
413 
414 
415  // Output solution
416  if (Case_id!=0)
417  {
418  sprintf(filename,"%s/soln_%i_%i.dat",Doc_info.directory().c_str(),
419  Case_id,Doc_info.number());
420  }
421  else
422  {
423  sprintf(filename,"%s/soln%i.dat",Doc_info.directory().c_str(),
424  Doc_info.number());
425  }
426  some_file.open(filename);
427  fish_mesh_pt()->output(some_file,npts);
428  some_file.close();
429 
430  // Write "load", vertical position of the fish back, and solution at
431  // control node to trace file
432  Trace_file
433  << static_cast<ElasticallySupportedRingElement*>(fish_mesh_pt()->
434  fish_back_pt())->load()
435  << " "
436  << static_cast<ElasticallySupportedRingElement*>(fish_mesh_pt()->
437  fish_back_pt())->y_c()
438  << " " << Doc_node_pt->value(0) << std::endl;
439 }
RefineableFishPoissonProblem::load
double & load()
Return value of the "load" on the elastically supported ring.
Definition: algebraic_free_boundary_poisson.cc:118
oomph::DocInfo::directory
std::string directory() const
Output directory.
Definition: oomph_utilities.h:524
oomph::Node::value
double value(const unsigned &i) const
Definition: nodes.cc:2408

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

◆ doc_solution() [2/7]

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [3/7]

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::doc_solution ( )

Doc the solution.

◆ doc_solution() [4/7]

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

Doc the solution in tecplot format.

Doc the solution. Output directory and labels are specified by DocInfo object

165 {
166 
167  unsigned min_refinement_level=0;
168  unsigned max_refinement_level=0;
169  mesh_pt()->get_refinement_levels(min_refinement_level,
170  max_refinement_level);
171 
172  oomph_info << "Min/max actual and max/min allowed refinement level"
173  << min_refinement_level << " "
174  << max_refinement_level << " "
175  << mesh_pt()->min_refinement_level() << " "
176  << mesh_pt()->max_refinement_level() << "\n";
177 
178 
179  ofstream some_file;
180  char filename[100];
181 
182  // Number of plot points in each coordinate direction.
183  unsigned npts;
184  npts=5;
185 
186  // Output solution
187  sprintf(filename,"%s/soln%i_on_proc%i.dat",doc_info.directory().c_str(),
188  doc_info.number(),this->communicator_pt()->my_rank());
189  some_file.open(filename);
190  mesh_pt()->output(some_file,npts);
191  some_file << "TEXT X=25,Y=93,F=HELV,HU=POINT,C=BLUE,H=10,T=\""
192  << doc_info.label() << "; Min/max: "
193  << min_refinement_level << " "
194  << max_refinement_level << " "
195  << "\"" << std::endl;
196  some_file.close();
197 
198 } // end of doc
RefineableFishPoissonProblem::doc_info
DocInfo & doc_info()
Access to DocInfo object.
Definition: algebraic_free_boundary_poisson.cc:136
oomph::DocInfo::label
std::string & label()
String used (e.g.) for labeling output files.
Definition: oomph_utilities.h:572

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

◆ doc_solution() [5/7]

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

Doc the solution. Output directory and labels are specified by DocInfo object

◆ doc_solution() [6/7]

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

Doc the solution. Output directory and labels are specified by DocInfo object

◆ doc_solution() [7/7]

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

Doc the solution. Output directory and labels are specified by DocInfo object

◆ fish_mesh_pt() [1/3]

template<class ELEMENT >
AlgebraicRefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt ( )
inline
113  {
114  return Fish_mesh_pt;
115  }

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ fish_mesh_pt() [2/3]

template<class ELEMENT >
MacroElementNodeUpdateRefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt ( )
inline
117  {
118  return Fish_mesh_pt;
119  }

◆ fish_mesh_pt() [3/3]

template<class ELEMENT >
AlgebraicRefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::fish_mesh_pt ( )
inline
274  {
275  return Fish_mesh_pt;
276  }

◆ load() [1/3]

template<class ELEMENT >
double& RefineableFishPoissonProblem< ELEMENT >::load ( )
inline

Return value of the "load" on the elastically supported ring.

119  {
120  return *Load_pt->value_pt(0);
121  }
oomph::Data::value_pt
double * value_pt(const unsigned &i) const
Definition: nodes.h:324

◆ load() [2/3]

template<class ELEMENT >
double& RefineableFishPoissonProblem< ELEMENT >::load ( )
inline

Return value of the "load" on the elastically supported ring that represents the fish's back

124  {
125  return *Load_pt->value_pt(0);
126  }

◆ load() [3/3]

template<class ELEMENT >
double& RefineableFishPoissonProblem< ELEMENT >::load ( )
inline

Return value of the "load" on the elastically supported ring.

280  {
281  return *Load_pt->value_pt(0);
282  }

◆ mesh_pt() [1/4]

template<class ELEMENT >
RefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

93  {
94  return dynamic_cast<RefineableFishMesh<ELEMENT>*>(Problem::mesh_pt());
95  }

◆ mesh_pt() [2/4]

template<class ELEMENT >
RefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

90  {
91  return dynamic_cast<RefineableFishMesh<ELEMENT>*>(Problem::mesh_pt());
92  }

◆ mesh_pt() [3/4]

template<class ELEMENT >
RefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

88  {
89  return dynamic_cast<RefineableFishMesh<ELEMENT>*>(Problem::mesh_pt());
90  }

◆ mesh_pt() [4/4]

template<class ELEMENT >
RefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::mesh_pt ( )
inline

Overloaded version of the problem's access function to the mesh. Recasts the pointer to the base Mesh object to the actual mesh type.

88  {
89  return dynamic_cast<RefineableFishMesh<ELEMENT>*>(Problem::mesh_pt());
90  }

◆ set_shape_deriv_method()

template<class ELEMENT >
void RefineableFishPoissonProblem< ELEMENT >::set_shape_deriv_method ( )
inlineprivate

Helper fct to set method for evaluation of shape derivs.

142  {
143 
144  bool done=false;
145 
146  //Loop over elements and set pointers to source function
147  unsigned n_element = fish_mesh_pt()->nelement();
148  for(unsigned i=0;i<n_element;i++)
149  {
150  // Upcast from FiniteElement to the present element
151  ELEMENT *el_pt = dynamic_cast<ELEMENT*>(fish_mesh_pt()->element_pt(i));
152 
153  // Direct FD
154  if (Case_id==0)
155  {
156  el_pt->evaluate_shape_derivs_by_direct_fd();
157  if (!done) std::cout << "\n\n [CR residuals] Direct FD" << std::endl;
158  }
159  // Chain rule with/without FD
160  else if ( (Case_id==1) || (Case_id==2) )
161  {
162  // It's broken but let's call it anyway to keep self-test alive
163  bool i_know_what_i_am_doing=true;
164  el_pt->evaluate_shape_derivs_by_chain_rule(i_know_what_i_am_doing);
165  if (Case_id==1)
166  {
167  el_pt->enable_always_evaluate_dresidual_dnodal_coordinates_by_fd();
168  if (!done) std::cout << "\n\n [CR residuals] Chain rule and FD"
169  << std::endl;
170  }
171  else
172  {
173  el_pt->disable_always_evaluate_dresidual_dnodal_coordinates_by_fd();
174  if (!done) std::cout << "\n\n [CR residuals] Chain rule and analytic"
175  << std::endl;
176  }
177  }
178  // Fastest with/without FD
179  else if ( (Case_id==3) || (Case_id==4) )
180  {
181  // It's broken but let's call it anyway to keep self-test alive
182  bool i_know_what_i_am_doing=true;
183  el_pt->evaluate_shape_derivs_by_fastest_method(i_know_what_i_am_doing);
184  if (Case_id==3)
185  {
186  el_pt->enable_always_evaluate_dresidual_dnodal_coordinates_by_fd();
187  if (!done) std::cout << "\n\n [CR residuals] Fastest and FD"
188  << std::endl;
189  }
190  else
191  {
192  el_pt->disable_always_evaluate_dresidual_dnodal_coordinates_by_fd();
193  if (!done) std::cout << "\n\n [CR residuals] Fastest and analytic"
194  << std::endl;
195 
196  }
197  }
198  done=true;
199  }
200 
201  }

References i.

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ y_c() [1/2]

template<class ELEMENT >
double& RefineableFishPoissonProblem< ELEMENT >::y_c ( )
inline

Return value of the vertical displacement of the ring that represents the fish's back

127  {
128  return static_cast<ElasticallySupportedRingElement*>(fish_mesh_pt()->
129  fish_back_pt())->y_c();
130  }

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ y_c() [2/2]

template<class ELEMENT >
double& RefineableFishPoissonProblem< ELEMENT >::y_c ( )
inline

Return value of the vertical displacement of the ring that represents the fish's back

131  {
132  return static_cast<ElasticallySupportedRingElement*>(fish_mesh_pt()->
133  fish_back_pt())->y_c();
134  }

Member Data Documentation

◆ Case_id

template<class ELEMENT >
unsigned RefineableFishPoissonProblem< ELEMENT >::Case_id
private

Case id.

◆ Doc_info

template<class ELEMENT >
DocInfo RefineableFishPoissonProblem< ELEMENT >::Doc_info
private

Doc info object.

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Doc_node_pt

template<class ELEMENT >
Node * RefineableFishPoissonProblem< ELEMENT >::Doc_node_pt
private

Node at which the solution of the Poisson equation is documented.

Node at which the solution of the Poisson equation is documented This solution at this node is also used as the "load" on the ring that represents the fish's back

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Fish_back_mesh_pt

template<class ELEMENT >
Mesh * RefineableFishPoissonProblem< ELEMENT >::Fish_back_mesh_pt
private

Pointer to single-element mesh that stores the GeneralisedElement that represents the fish back

Pointer to single-element mesh that stores the GeneralisedElement that represents the fish's back

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Fish_mesh_pt [1/2]

template<class ELEMENT >
AlgebraicRefineableFishMesh< ELEMENT > * RefineableFishPoissonProblem< ELEMENT >::Fish_mesh_pt
private

Pointer to fish mesh.

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Fish_mesh_pt [2/2]

template<class ELEMENT >
MacroElementNodeUpdateRefineableFishMesh<ELEMENT>* RefineableFishPoissonProblem< ELEMENT >::Fish_mesh_pt
private

Pointer to fish mesh.

◆ Fix_position

template<class ELEMENT >
bool RefineableFishPoissonProblem< ELEMENT >::Fix_position
private

Is the position of the fish back prescribed?

Is the position of the fish's back prescribed?

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Load_pt

template<class ELEMENT >
Data * RefineableFishPoissonProblem< ELEMENT >::Load_pt
private

Pointer to data item that stores the "load" on the fish back.

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

◆ Trace_file

template<class ELEMENT >
ofstream RefineableFishPoissonProblem< ELEMENT >::Trace_file
private

Trace file.

Referenced by RefineableFishPoissonProblem< ELEMENT >::RefineableFishPoissonProblem().

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