beam_elements.h
Go to the documentation of this file.
1 //LIC// ====================================================================
2 //LIC// This file forms part of oomph-lib, the object-oriented,
3 //LIC// multi-physics finite-element library, available
4 //LIC// at http://www.oomph-lib.org.
5 //LIC//
6 //LIC// Version 1.0; svn revision $LastChangedRevision: 1182 $
7 //LIC//
8 //LIC// $LastChangedDate: 2016-05-20 16:50:20 +0100 (Fri, 20 May 2016) $
9 //LIC//
10 //LIC// Copyright (C) 2006-2016 Matthias Heil and Andrew Hazel
11 //LIC//
12 //LIC// This library is free software; you can redistribute it and/or
13 //LIC// modify it under the terms of the GNU Lesser General Public
14 //LIC// License as published by the Free Software Foundation; either
15 //LIC// version 2.1 of the License, or (at your option) any later version.
16 //LIC//
17 //LIC// This library is distributed in the hope that it will be useful,
18 //LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
19 //LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 //LIC// Lesser General Public License for more details.
21 //LIC//
22 //LIC// You should have received a copy of the GNU Lesser General Public
23 //LIC// License along with this library; if not, write to the Free Software
24 //LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 //LIC// 02110-1301 USA.
26 //LIC//
27 //LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
28 //LIC//
29 //LIC//====================================================================
30 //Header file for KL beam elements
31 #ifndef OOMPH_KIRCHHOFF_LOVE_BEAM_ELEMENTS_HEADER
32 #define OOMPH_KIRCHHOFF_LOVE_BEAM_ELEMENTS_HEADER
33 
34 // Config header generated by autoconfig
35 #ifdef HAVE_CONFIG_H
36  #include <oomph-lib-config.h>
37 #endif
38 
39 //OOMPH-LIB header files
40 #include "../generic/hermite_elements.h"
41 #include "../generic/geom_objects.h"
42 #include "../generic/fsi.h"
43 #include "../generic/block_preconditioner.h"
44 
45 namespace oomph
46 {
47 
48 //=======================================================================
49 /// A class for elements that solve the equations of Kirchhoff-Love
50 /// large-displacement (but linearly-elastic) thin-beam theory.
51 ///
52 /// The variational principle has the form
53 /// \f[
54 /// \int_0^{L} \left[
55 /// (\sigma_0 + \gamma) \ \delta
56 /// \gamma +
57 /// \frac{1}{12} \left(\frac{h}{R_0}\right)^2 \kappa
58 /// \ \delta \kappa -
59 /// \left( \left(\frac{R_0}{h}\right) {\bf f} - \Lambda^2
60 /// \frac{\partial^2 {\bf R}_w}{\partial t^2} \right) \cdot
61 /// \delta {\bf R}_w
62 /// \right] \ d\xi = 0,
63 /// \f]
64 /// where all lengths have been non-dimensionalised w.r.t. \f$ R_0 \f$.
65 /// The strain and and bending "tensors" \f$\gamma\f$ and \f$\kappa\f$
66 /// are computed relative to the shape of the beam's undeformed shape
67 /// which is specified as a GeomObject.
68 ///
69 /// Time is scaled on the timescale \f$T\f$ and
70 /// \f[
71 /// \Lambda = \frac{a}{T} \sqrt{\frac{\rho}{E_{eff}}},
72 /// \f]
73 /// the ratio of the timescale used in the non-dimensionalisation of the
74 /// equations to the natural timescale of the wall oscillations (in the
75 /// wall's in-plane mode). \f$ \Lambda^2 \f$ can be interpreted as
76 /// the non-dimensional wall density, therefore \f$ \Lambda=0\f$
77 /// corresponds to the case without wall inertia.
78 ///
79 ///
80 /// Note that:
81 /// - the load vector \f$ {\bf f} \f$ is scaled
82 /// on the effective elastic modulus \f$ E_{eff}=E/(1-\nu^2)\f$
83 /// (rather than the
84 /// bending stiffness). Rescale the result yourself if you prefer
85 /// another non-dimensionalisation (the current version yields the
86 /// the most compact maths).
87 /// - Poisson's ratio does not appear explicitly since it only occurs
88 /// in combination with Young's modulus \f$E\f$.
89 ///
90 /// Default values:
91 /// - the 2nd Piola Kirchhoff pre-stress \f$ \sigma_0 \f$ is zero.
92 /// - the wall thickness \f$ h/R_0\f$ is 1/20.
93 /// - the timescale ratio \f$ \Lambda^2\f$ is 1.
94 /// - the traction vector \f$ f \f$ evaluates to zero.
95 ///
96 /// Need to specify:
97 /// - the undeformed wall shape (as a GeomObject).
98 ///
99 /// The governing equations can be switched from the principle of
100 /// virtual displacements to a system of equations that forces the
101 /// beam to deform into a shape specified by a SolidInitialCondition object.
102 /// If \c SolidFiniteElement::solid_ic_pt()!=0 we solve the
103 /// the equations
104 /// \f[
105 /// \int_0^{L} \left(
106 /// \frac{\partial^i {\bf R}_{IC}}{\partial t^i} - {\bf R}_w
107 /// \right) \psi_{jk} \ d\xi = 0,
108 /// \f]
109 /// where \f$ \partial^i {\bf R}_{IC}/\partial t^i\f$ is
110 /// implemented by the SolidInitialCondition object, pointed to by
111 /// \c SolidFiniteElement::shell_ic_pt().
112 ///
113 //=======================================================================
115 {
116 
117 private:
118 
119  /// Static default value for 2nd Piola Kirchhoff prestress
120  static double Default_sigma0_value;
121 
122  /// Static default value for timescale ratio (1.0 -- for natural scaling)
123  static double Default_lambda_sq_value;
124 
125  /// Static default value for non-dim wall thickness
126  // i.e. The reference value 'h_0'
127  static double Default_h_value;
128 
129  /// Pointer to axial prestress
130  double* Sigma0_pt;
131 
132  /// Pointer to wall thickness
133  // i.e. The reference value 'h_0'
134  double* H_pt;
135 
136  /// Pointer to Timescale ratio (non-dim. density)
137  double *Lambda_sq_pt;
138 
139 protected:
140 
141  /// Default load function (zero traction)
142  static void Zero_traction_fct(const Vector<double>& xi,
143  const Vector<double> &x,
144  const Vector<double>& N,
145  Vector<double>& load);
146 
147  /// \short Pointer to load vector function: Its arguments are:
148  /// Lagrangian coordinate, Eulerian coordinate, normal vector and
149  /// load vector itself (not all of the input arguments will be
150  /// required for all specific load functions but the list should
151  /// cover all cases)
153  const Vector<double> &x,
154  const Vector<double>& N,
155  Vector<double>& load);
156 
157  /// Default profile function (constant thickness 'h_0')
158  static void Unit_profile_fct(const Vector<double>& xi,
159  const Vector<double>& x,
160  double& h_ratio);
161 
162  /// \short Pointer to wall profile function: Its arguments are:
163  /// Lagrangian coordinate, Eulerian coordinate, and
164  /// profile itself (not all of the input arguments will be
165  /// required for all specific profile functions but the list should
166  /// cover all cases)
168  const Vector<double>& x,
169  double& h_ratio);
170 
171  /// \short Pointer to the GeomObject that specifies the beam's
172  /// undeformed midplane
174 
175 public:
176 
177  /// \short Constructor. Set default values for all physical parameters
178  /// and zero traction.
180  {
181  //Set physical parameter pointers to the default values
184  // The reference thickness 'h_0'
186  // Zero traction
188  // Unit thickness profile
190  }
191 
192 
193  /// Reference to the load vector function pointer
194  void (* &load_vector_fct_pt())(const Vector<double>& xi,
195  const Vector<double>& x,
196  const Vector<double>& N,
197  Vector<double>& load)
198  {return Load_vector_fct_pt;}
199 
200 
201  /// \short Get the load vector: Pass number of integration point (dummy),
202  /// Lagr. and Eulerian coordinate and normal vector and return the load vector
203  /// (not all of the input arguments will be
204  /// required for all specific load functions but the list should
205  /// cover all cases). This function is virtual so it can be
206  /// overloaded for FSI.
207  virtual void load_vector(const unsigned& intpt,
208  const Vector<double>& xi,
209  const Vector<double>& x,
210  const Vector<double>& N,
211  Vector<double>& load)
212  {
213  Load_vector_fct_pt(xi,x,N,load);
214  }
215 
216  /// Reference to the wall thickness ratio profile function pointer
217  void (* &wall_profile_fct_pt())(const Vector<double>& xi,
218  const Vector<double>& x,
219  double& h_ratio)
220  {return Wall_profile_fct_pt;}
221 
222 
223  /// \short Get the wall profile: Pass Lagrangian & Eulerian coordinate
224  /// and return the wall profile (not all of the input arguments will be
225  /// required for all specific thickness functions but the list should cover
226  /// all cases).
227  void wall_profile(const Vector<double>& xi,
228  const Vector<double>& x,
229  double& h_ratio)
230  {
231  Wall_profile_fct_pt(xi,x,h_ratio);
232  }
233 
234 
235  /// Return the non-dimensional wall thickness
236  // i.e. the reference value 'h_0'
237  const double &h() const {return *H_pt;}
238 
239  /// Return the timescale ratio (non-dimensional density)
240  const double& lambda_sq() const {return *Lambda_sq_pt;}
241 
242  /// Return the axial prestress
243  const double &sigma0() const {return *Sigma0_pt;}
244 
245  /// Return a pointer to axial prestress
246  double* &sigma0_pt() {return Sigma0_pt;}
247 
248  /// Return a pointer to non-dim. wall thickness
249  // i.e. the reference value 'h_0'
250  double* &h_pt() {return H_pt;}
251 
252  /// Return a pointer to timescale ratio (nondim density)
253  double* &lambda_sq_pt() {return Lambda_sq_pt;}
254 
255  /// \short Return a Pointer to geometric object that specifies the beam's
256  /// undeformed geometry
258 
259  /// Get normal vector on wall
261  {
262  Vector<double> r(2);
263  get_normal(s,r,N);
264  }
265 
266 
267  /// Get position vector to and normal vector on wall
268  void get_normal(const Vector<double>& s,
269  Vector<double>& r,
270  Vector<double>& N);
271 
272  /// \short Get position vector to and non-unit tangent vector on wall:
273  /// dr/ds
275  Vector<double>& r,
276  Vector<double>& drds);
277 
278  /// \short Return the residuals for the equations of Kirchhoff-Love beam
279  /// theory with linear constitutive equations; if Solid_ic_pt!=0, we
280  /// assign residuals which force the assignement of an initial shape/
281  /// veloc/accel to the dofs. This overloads the standard interface.
283  {
285  }
286 
287 
288  /// \short Return the residuals for the equations of Kirchhoff-Love beam
289  /// theory with linear constitutive equations; if Solid_ic_pt!=0, we
290  /// assign residuals which force the assignement of an initial shape/
291  /// veloc/accel to the dofs.
293 
294 
295  /// Get FE jacobian and residuals (Jacobian done by finite differences)
296  virtual void fill_in_contribution_to_jacobian(Vector<double> &residuals,
297  DenseMatrix<double> &jacobian);
298 
299  /// \short Get potential (strain) and kinetic energy of the element
300  void get_energy(double& pot_en, double& kin_en);
301 
302  /// \short Get the potential energy due to stretching and bending and the
303  /// kinetic energy of the element
304  void get_energy(double &stretch, double &bend, double &kin_en);
305 
306 };
307 
308 
309 //=========================================================================
310 /// \short Hermite Kirchhoff Love beam. Implements KirchhoffLoveBeamEquations
311 /// using 2-node Hermite elements as the underlying geometrical elements.
312 //=========================================================================
313 class HermiteBeamElement : public virtual SolidQHermiteElement<1>,
315 {
316  public:
317 
318  /// Constructor (empty)
321  {
322  //Set the number of dimensions at each node (2D node on 1D surface)
324  }
325 
326  /// Output function
327  void output(std::ostream &outfile);
328 
329  /// Output function with specified number of plot points
330  void output(std::ostream &outfile, const unsigned &n_plot);
331 
332  /// \short Output at previous time (t=0: present; t>0: previous)
333  /// with specified number of plot points
334  void output(const unsigned& t, std::ostream &outfile, const unsigned &n_plot) const;
335 
336  /// C-style output function
337  void output(FILE* file_pt);
338 
339  /// C-style output function with specified number of plot points
340  void output(FILE* file_pt, const unsigned &n_plot);
341 
342  /// \short C-style output at previous time (t=0: present; t>0: previous)
343  /// with specified number of plot points
344  void output(const unsigned& t, FILE* file_pt, const unsigned &n_plot) const;
345 
346 };
347 
348 //=========================================================================
349 /// Hermite Kirchhoff Love beam "upgraded" to a FSIWallElement (and thus,
350 /// by inheritance, a GeomObject), so it can be used in FSI.
351 //=========================================================================
353  public virtual FSIWallElement
354 {
355  private:
356 
357  //Boolean flag to indicate whether the normal is directed into the fluid
359 
360  public:
361 
362  /// \short Constructor: Create beam element as FSIWallElement (and thus,
363  /// by inheritance, a GeomObject). By default, we assume that the
364  /// normal vector computed by KirchhoffLoveBeamEquations::get_normal(...)
365  /// points into the fluid. If this is not the case, overwrite this
366  /// with the access function
367  /// FSIHermiteBeamElement::set_normal_pointing_out_of_fluid()
370  {
371  unsigned n_lagr=1;
372  unsigned n_dim=2;
373  setup_fsi_wall_element(n_lagr,n_dim);
374  }
375 
376  /// \short Destructor: empty
378 
379  /// \short Set the normal computed by
380  /// KirchhoffLoveBeamEquations::get_normal(...) to point into the fluid
382 
383  /// \short Set the normal computed by
384  /// KirchhoffLoveBeamEquations::get_normal(...) to point out of the fluid
386 
387 
388  /// \short Derivative of position vector w.r.t. the SolidFiniteElement's
389  /// Lagrangian coordinates; evaluated at current time.
391  const Vector<double>& s, DenseMatrix<double> &drdxi) const;
392 
393  /// \short Get the load vector: Pass number of the integration point,
394  /// Lagr. coordinate, Eulerian coordinate and normal vector
395  /// and return the load vector. (Not all of the input arguments will be
396  /// required for all specific load functions but the list should
397  /// cover all cases). We first evaluate the load function defined via
398  /// KirchhoffLoveBeamEquations::load_vector_fct_pt() -- this
399  /// represents the non-FSI load on the beam, e.g. an external
400  /// pressure load. Then we add to this the FSI load due to
401  /// the traction exerted by the adjacent FSIFluidElements, taking
402  /// the sign of the normal into account.
403  void load_vector(const unsigned& intpt,
404  const Vector<double>& xi,
405  const Vector<double>& x,
406  const Vector<double>& N,
407  Vector<double>& load)
408  {
409  //Initially call the standard Load_vector_fct_pt
410  Load_vector_fct_pt(xi,x,N,load);
411 
412  //Memory for the FSI load
413  Vector<double> fsi_load(2);
414 
415  //Get the fluid load on the wall stress scale
416  fluid_load_vector(intpt,N,fsi_load);
417 
418  //If the normal is outer to the fluid switch the direction
419  double sign = 1.0;
420  if (!Normal_points_into_fluid) {sign = -1.0;}
421 
422  //Add the FSI load to the load vector
423  for(unsigned i=0;i<2;i++)
424  {
425  load[i] += sign*fsi_load[i];
426  }
427  }
428 
429  /// \short Get the Jacobian and residuals. Wrapper to generic FSI version;
430  /// that catches the case when we replace the Jacobian by the
431  /// mass matrix (for the consistent assignment of initial conditions).
433  DenseMatrix<double> &jacobian)
434  {
435  //Call the standard beam element's jacobian function
437  //Now add the external interaction data by finite differences
439  }
440 
441  /// \short Find the local coordinate s in this element
442  /// that corresponds to the global "intrinsic" coordinate \f$ \zeta \f$
443  /// (here identical to the Lagrangian coordinate \f$ \xi \f$).
444  /// If the coordinate is contained within this element, the
445  /// geom_object_pt points to "this" element; if the zeta coordinate
446  /// is not contained in this element geom_object_pt=NULL.
447  /// By default don't use any value passed in to the local coordinate s
448  /// as the initial guess in the Newton method
449  void locate_zeta(const Vector<double> &zeta,
450  GeomObject* &geom_object_pt, Vector<double> &s,
451  const bool& use_coordinate_as_initial_guess=false);
452 
453 
454 
455  /// \short The number of "DOF types" that degrees of freedom in this element
456  /// are sub-divided into: Just the solid degrees of freedom themselves.
457  unsigned ndof_types() const
458  {
459  return 1;
460  }
461 
462  /// \short Create a list of pairs for all unknowns in this element,
463  /// so that the first entry in each pair contains the global equation
464  /// number of the unknown, while the second one contains the number
465  /// of the "DOF type" that this unknown is associated with.
466  /// (Function can obviously only be called if the equation numbering
467  /// scheme has been set up.)
469  std::list<std::pair<unsigned long,unsigned> >& dof_lookup_list) const;
470 
471 };
472 
473 
474 
475 ///////////////////////////////////////////////////////////////////////
476 ///////////////////////////////////////////////////////////////////////
477 ///////////////////////////////////////////////////////////////////////
478 
479 
480 
481 //=======================================================================
482 /// Face geometry for the HermiteBeam elements: Solid point element
483 //=======================================================================
484 template<>
486 {
487 
488  public:
489 
490  /// \short Constructor [this was only required explicitly
491  /// from gcc 4.5.2 onwards...]
493 
494 };
495 
496 
497 
498 ///////////////////////////////////////////////////////////////////////
499 ///////////////////////////////////////////////////////////////////////
500 ///////////////////////////////////////////////////////////////////////
501 
502 
503 
504 //======================================================================
505 /// Element that allows the imposition of boundary
506 /// conditions for a beam that is clamped but can slide
507 /// along a line which is specified by a position vector
508 /// to that line and the normal vector to it. The endpoint
509 /// of the beam is forced to stay on that line and meet
510 /// it at a right angle. This is achieved with Lagrange multipliers.
511 //======================================================================
513 : public virtual FaceGeometry<HermiteBeamElement>,
514  public virtual SolidFaceElement
515 {
516 
517 public:
518 
519  /// \short Constructor, takes the pointer to the "bulk" element, the
520  /// index of the fixed local coordinate and its value represented
521  /// by an integer (+/- 1), indicating that the face is located
522  /// at the max. or min. value of the "fixed" local coordinate
523  /// in the bulk element.
525  FiniteElement* const &bulk_el_pt, const int& face_index);
526 
527  ///\short Broken empty constructor
529  {
530  throw OomphLibError(
531  "Don't call empty constructor for ClampedSlidingHermiteBeamBoundaryConditionElement ",
532  OOMPH_CURRENT_FUNCTION,
533  OOMPH_EXCEPTION_LOCATION);
534  }
535 
536 
537  /// Broken copy constructor
540  {
542  "ClampedSlidingHermiteBeamBoundaryConditionElement");
543  }
544 
545  /// Broken assignment operator
546 //Commented out broken assignment operator because this can lead to a conflict warning
547 //when used in the virtual inheritence hierarchy. Essentially the compiler doesn't
548 //realise that two separate implementations of the broken function are the same and so,
549 //quite rightly, it shouts.
550  /*void operator=(const ClampedSlidingHermiteBeamBoundaryConditionElement&)
551  {
552  BrokenCopy::broken_assign(
553  "ClampedSlidingHermiteBeamBoundaryConditionElement");
554  }*/
555 
556 
557  /// \short Set vectors to some point on the symmetry line, and
558  /// normal to that line along which the end of the beam is sliding.
559  void set_symmetry_line(const Vector<double>& vector_to_symmetry_line,
560  const Vector<double>& normal_to_symmetry_line)
561  {
562  Vector_to_symmetry_line[0]=vector_to_symmetry_line[0];
563  Vector_to_symmetry_line[1]=vector_to_symmetry_line[1];
564  Normal_to_symmetry_line[0]=normal_to_symmetry_line[0];
565  Normal_to_symmetry_line[1]=normal_to_symmetry_line[1];
566  }
567 
568 
569  /// Fill in the element's contribution to its residual vector
571 
572 
573  /// Output function -- forward to broken version in FiniteElement
574  /// until somebody decides what exactly they want to plot here...
575  void output(std::ostream &outfile) {FiniteElement::output(outfile);}
576 
577  /// \short Output function -- forward to broken version in FiniteElement
578  /// until somebody decides what exactly they want to plot here...
579  void output(std::ostream &outfile, const unsigned &n_plot)
580  {FiniteElement::output(outfile,n_plot);}
581 
582  /// C-style output function -- forward to broken version in FiniteElement
583  /// until somebody decides what exactly they want to plot here...
584  void output(FILE* file_pt) {FiniteElement::output(file_pt);}
585 
586  /// \short C-style output function -- forward to broken version in
587  /// FiniteElement until somebody decides what exactly they want to plot
588  /// here...
589  void output(FILE* file_pt, const unsigned &n_plot)
590  {FiniteElement::output(file_pt,n_plot);}
591 
592 private:
593 
594  /// \short Vector to some point on the symmetry line along which the
595  /// end of the beam is sliding
597 
598  /// \short Normal vector to the symmetry line along which the
599  /// end of the beam is sliding
601 
602 };
603 
604 
605 
606 }
607 
608 #endif
609 
610 
611 
612 
613 
void broken_copy(const std::string &class_name)
Issue error message and terminate execution.
virtual void load_vector(const unsigned &intpt, const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
Get the load vector: Pass number of integration point (dummy), Lagr. and Eulerian coordinate and norm...
ClampedSlidingHermiteBeamBoundaryConditionElement(const ClampedSlidingHermiteBeamBoundaryConditionElement &dummy)
Broken copy constructor.
This is a base class for all SolidFiniteElements that participate in FSI computations. These elements provide interfaces and generic funcionality for the two additional roles that SolidFiniteElements play in FSI problems:They parameterise the domain boundary for the fluid domain. To allow them to play this role, FSIWallElements are derived from the SolidFiniteElement and the GeomObject class, indicating that the every specific FSIWallElement must implement the pure virtual function GeomObject::position(...) which should compute the position vector to a point in the SolidFiniteElement, parametrised by its local coordinates.In FSI problems fluid exerts a traction onto the wall and this traction must be added to any other load terms (such as an external pressure acting on an elastic pipe) that are already applied to the SolidFiniteElements by other means.
Definition: fsi.h:210
Vector< double > Vector_to_symmetry_line
Vector to some point on the symmetry line along which the end of the beam is sliding.
void output(std::ostream &outfile, const unsigned &n_plot)
Output function – forward to broken version in FiniteElement until somebody decides what exactly they...
virtual void output(std::ostream &outfile)
Output the element data — typically the values at the nodes in a format suitable for post-processing...
Definition: elements.h:2872
double *& sigma0_pt()
Return a pointer to axial prestress.
void wall_profile(const Vector< double > &xi, const Vector< double > &x, double &h_ratio)
Get the wall profile: Pass Lagrangian & Eulerian coordinate and return the wall profile (not all of t...
KirchhoffLoveBeamEquations()
Constructor. Set default values for all physical parameters and zero traction.
cstr elem_len * i
Definition: cfortran.h:607
int & face_index()
Index of the face (a number that uniquely identifies the face in the element)
Definition: elements.h:4367
void fill_in_jacobian_from_external_interaction_by_fd(Vector< double > &residuals, DenseMatrix< double > &jacobian)
Calculate the contributions to the jacobian from all external interaction degrees of freedom (geometr...
static void Unit_profile_fct(const Vector< double > &xi, const Vector< double > &x, double &h_ratio)
Default profile function (constant thickness 'h_0')
virtual void fill_in_contribution_to_jacobian(Vector< double > &residuals, DenseMatrix< double > &jacobian)
Get FE jacobian and residuals (Jacobian done by finite differences)
A general Finite Element class.
Definition: elements.h:1271
void get_dof_numbers_for_unknowns(std::list< std::pair< unsigned long, unsigned > > &dof_lookup_list) const
Create a list of pairs for all unknowns in this element, so that the first entry in each pair contain...
HermiteBeamElement()
Constructor (empty)
void setup_fsi_wall_element(const unsigned &nlagr_solid, const unsigned &ndim_fluid)
Setup: Assign storage – pass the Eulerian dimension of the "adjacent" fluid elements and the number o...
Definition: fsi.cc:124
char t
Definition: cfortran.h:572
double *& h_pt()
Return a pointer to non-dim. wall thickness.
void fill_in_contribution_to_residuals(Vector< double > &residuals)
Return the residuals for the equations of Kirchhoff-Love beam theory with linear constitutive equatio...
void(* Load_vector_fct_pt)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
Pointer to load vector function: Its arguments are: Lagrangian coordinate, Eulerian coordinate...
const double & lambda_sq() const
Return the timescale ratio (non-dimensional density)
FaceGeometry()
Constructor [this was only required explicitly from gcc 4.5.2 onwards...].
ClampedSlidingHermiteBeamBoundaryConditionElement()
Broken empty constructor.
virtual void fill_in_contribution_to_jacobian(Vector< double > &residuals, DenseMatrix< double > &jacobian)
Get the Jacobian and residuals. Wrapper to generic FSI version; that catches the case when we replace...
Vector< double > Normal_to_symmetry_line
Normal vector to the symmetry line along which the end of the beam is sliding.
void load_vector(const unsigned &intpt, const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
Get the load vector: Pass number of the integration point, Lagr. coordinate, Eulerian coordinate and ...
~FSIHermiteBeamElement()
Destructor: empty.
FSIHermiteBeamElement()
Constructor: Create beam element as FSIWallElement (and thus, by inheritance, a GeomObject). By default, we assume that the normal vector computed by KirchhoffLoveBeamEquations::get_normal(...) points into the fluid. If this is not the case, overwrite this with the access function FSIHermiteBeamElement::set_normal_pointing_out_of_fluid()
void get_normal(const Vector< double > &s, Vector< double > &N)
Get normal vector on wall.
double * H_pt
Pointer to wall thickness.
const double & sigma0() const
Return the axial prestress.
static double Default_lambda_sq_value
Static default value for timescale ratio (1.0 – for natural scaling)
static char t char * s
Definition: cfortran.h:572
static void Zero_traction_fct(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load)
Default load function (zero traction)
Hermite Kirchhoff Love beam. Implements KirchhoffLoveBeamEquations using 2-node Hermite elements as t...
static double Default_h_value
Static default value for non-dim wall thickness.
const double & h() const
Return the non-dimensional wall thickness.
void fill_in_contribution_to_residuals_beam(Vector< double > &residuals)
Return the residuals for the equations of Kirchhoff-Love beam theory with linear constitutive equatio...
void fluid_load_vector(const unsigned &intpt, const Vector< double > &N, Vector< double > &load)
Get FE Jacobian by systematic finite differencing w.r.t. nodal positition Data, internal and external...
Definition: fsi.cc:166
double * Lambda_sq_pt
Pointer to Timescale ratio (non-dim. density)
GeomObject *& undeformed_beam_pt()
Return a Pointer to geometric object that specifies the beam's undeformed geometry.
void output(FILE *file_pt, const unsigned &n_plot)
C-style output function – forward to broken version in FiniteElement until somebody decides what exac...
void set_normal_pointing_out_of_fluid()
Set the normal computed by KirchhoffLoveBeamEquations::get_normal(...) to point out of the fluid...
void(*&)(const Vector< double > &xi, const Vector< double > &x, const Vector< double > &N, Vector< double > &load) load_vector_fct_pt()
Reference to the load vector function pointer.
void set_normal_pointing_into_fluid()
Set the normal computed by KirchhoffLoveBeamEquations::get_normal(...) to point into the fluid...
void get_non_unit_tangent(const Vector< double > &s, Vector< double > &r, Vector< double > &drds)
Get position vector to and non-unit tangent vector on wall: dr/ds.
void dposition_dlagrangian_at_local_coordinate(const Vector< double > &s, DenseMatrix< double > &drdxi) const
Derivative of position vector w.r.t. the SolidFiniteElement's Lagrangian coordinates; evaluated at cu...
void output(std::ostream &outfile)
Output function.
void set_symmetry_line(const Vector< double > &vector_to_symmetry_line, const Vector< double > &normal_to_symmetry_line)
Broken assignment operator.
GeomObject * Undeformed_beam_pt
Pointer to the GeomObject that specifies the beam's undeformed midplane.
void get_energy(double &pot_en, double &kin_en)
Get potential (strain) and kinetic energy of the element.
void set_nodal_dimension(const unsigned &nodal_dim)
Set the dimension of the nodes in the element. This will typically only be required when constructing...
Definition: elements.h:1348
void(* Wall_profile_fct_pt)(const Vector< double > &xi, const Vector< double > &x, double &h_ratio)
Pointer to wall profile function: Its arguments are: Lagrangian coordinate, Eulerian coordinate...
void(*&)(const Vector< double > &xi, const Vector< double > &x, double &h_ratio) wall_profile_fct_pt()
Reference to the wall thickness ratio profile function pointer.
void locate_zeta(const Vector< double > &zeta, GeomObject *&geom_object_pt, Vector< double > &s, const bool &use_coordinate_as_initial_guess=false)
Find the local coordinate s in this element that corresponds to the global "intrinsic" coordinate ...
void fill_in_contribution_to_residuals(Vector< double > &residuals)
Fill in the element's contribution to its residual vector.
unsigned ndof_types() const
The number of "DOF types" that degrees of freedom in this element are sub-divided into: Just the soli...
double * Sigma0_pt
Pointer to axial prestress.
static double Default_sigma0_value
Static default value for 2nd Piola Kirchhoff prestress.
SolidFiniteElement class.
Definition: elements.h:3320
Solid point element.
Definition: elements.h:4685
double *& lambda_sq_pt()
Return a pointer to timescale ratio (nondim density)