linear_elasticity_elements.cc
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: 1097 $
7 //LIC//
8 //LIC// $LastChangedDate: 2015-12-17 11:53:17 +0000 (Thu, 17 Dec 2015) $
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 // Non-inline functions for elements that solve the equations of linear
31 // elasticity in cartesian coordinates
32 
34 
35 
36 namespace oomph
37 {
38 
39 
40 /// Static default value for timescale ratio (1.0 -- for natural scaling)
41 template <unsigned DIM>
42 double LinearElasticityEquationsBase<DIM>::Default_lambda_sq_value=1.0;
43 
44 
45 //////////////////////////////////////////////////////////////////
46 //////////////////////////////////////////////////////////////////
47 //////////////////////////////////////////////////////////////////
48 
49 //======================================================================
50 /// Compute the strain tensor at local coordinate s
51 //======================================================================
52  template<unsigned DIM>
54  const Vector<double> &s,
55  DenseMatrix<double> &strain) const
56  {
57 #ifdef PARANOID
58  if ((strain.ncol()!=DIM)||(strain.nrow()!=DIM))
59  {
60  std::ostringstream error_message;
61  error_message << "Strain matrix is " << strain.ncol() << " x "
62  << strain.nrow() << ", but dimension of the equations is "
63  << DIM << std::endl;
64  throw OomphLibError(error_message.str(),
65  OOMPH_CURRENT_FUNCTION,
66  OOMPH_EXCEPTION_LOCATION);
67  }
68 
69  //Find out how many position types there are
70  unsigned n_position_type = this->nnodal_position_type();
71 
72  if(n_position_type != 1)
73  {
74  throw OomphLibError(
75  "LinearElasticity is not yet implemented for more than one position type",
76  OOMPH_CURRENT_FUNCTION,
77  OOMPH_EXCEPTION_LOCATION);
78  }
79 #endif
80 
81 
82  //Find out how many nodes there are in the element
83  unsigned n_node = nnode();
84 
85  //Find the indices at which the local velocities are stored
86  unsigned u_nodal_index[DIM];
87  for(unsigned i=0;i<DIM;i++) {u_nodal_index[i] = u_index_linear_elasticity(i);}
88 
89  //Set up memory for the shape and derivative functions
90  Shape psi(n_node);
91  DShape dpsidx(n_node,DIM);
92 
93  //Call the derivatives of the shape functions
94  (void) dshape_eulerian(s,psi,dpsidx);
95 
96  //Calculate interpolated values of the derivative of global position
97  DenseMatrix<double> interpolated_dudx(DIM,DIM,0.0);
98 
99  //Loop over nodes
100  for(unsigned l=0;l<n_node;l++)
101  {
102  //Loop over velocity components
103  for(unsigned i=0;i<DIM;i++)
104  {
105  //Get the nodal value
106  const double u_value = this->nodal_value(l,u_nodal_index[i]);
107 
108  //Loop over derivative directions
109  for(unsigned j=0;j<DIM;j++)
110  {
111  interpolated_dudx(i,j) += u_value*dpsidx(l,j);
112  }
113  }
114  }
115 
116  ///Now fill in the entries of the strain tensor
117  for(unsigned i=0;i<DIM;i++)
118  {
119  //Do upper half of matrix
120  //Note that j must be signed here for the comparison test to work
121  //Also i must be cast to an int
122  for(int j=(DIM-1);j>=static_cast<int>(i);j--)
123  {
124  //Off diagonal terms
125  if(static_cast<int>(i)!=j)
126  {
127  strain(i,j) =
128  0.5*(interpolated_dudx(i,j) + interpolated_dudx(j,i));
129  }
130  //Diagonal terms will including growth factor when it comes back in
131  else
132  {
133  strain(i,i) = interpolated_dudx(i,i);
134  }
135  }
136  //Matrix is symmetric so just copy lower half
137  for(int j=(i-1);j>=0;j--)
138  {
139  strain(i,j) = strain(j,i);
140  }
141  }
142  }
143 
144 
145 
146 
147 
148 //======================================================================
149 /// Compute the Cauchy stress tensor at local coordinate s for
150 /// displacement formulation.
151 //======================================================================
152 template<unsigned DIM>
154  DenseMatrix<double> &stress)
155  const
156 {
157 #ifdef PARANOID
158  if ((stress.ncol()!=DIM)||(stress.nrow()!=DIM))
159  {
160  std::ostringstream error_message;
161  error_message << "Stress matrix is " << stress.ncol() << " x "
162  << stress.nrow() << ", but dimension of the equations is "
163  << DIM << std::endl;
164  throw OomphLibError(error_message.str(),
165  OOMPH_CURRENT_FUNCTION,
166  OOMPH_EXCEPTION_LOCATION);
167  }
168 #endif
169 
170  // Get strain
171  DenseMatrix<double> strain(DIM,DIM);
172  this->get_strain(s,strain);
173 
174  // Now fill in the entries of the stress tensor without exploiting
175  // symmetry -- sorry too lazy. This fct is only used for
176  // postprocessing anyway...
177  for(unsigned i=0;i<DIM;i++)
178  {
179  for(unsigned j=0;j<DIM;j++)
180  {
181  stress(i,j) = 0.0;
182  for (unsigned k=0;k<DIM;k++)
183  {
184  for (unsigned l=0;l<DIM;l++)
185  {
186  stress(i,j)+=this->E(i,j,k,l)*strain(k,l);
187  }
188  }
189  }
190  }
191 }
192 
193 
194 //=======================================================================
195 /// Compute the residuals for the linear elasticity equations in
196 /// cartesian coordinates. Flag indicates if we want Jacobian too.
197 //=======================================================================
198  template <unsigned DIM>
201  Vector<double> &residuals, DenseMatrix<double> &jacobian,unsigned flag)
202  {
203  //Find out how many nodes there are
204  unsigned n_node = this->nnode();
205 
206 #ifdef PARANOID
207  //Find out how many positional dofs there are
208  unsigned n_position_type = this->nnodal_position_type();
209 
210  if(n_position_type != 1)
211  {
212  throw OomphLibError(
213  "LinearElasticity is not yet implemented for more than one position type",
214  OOMPH_CURRENT_FUNCTION,
215  OOMPH_EXCEPTION_LOCATION);
216  }
217 
218  //Throw and error if an elasticity tensor has not been set
219  if(this->Elasticity_tensor_pt==0)
220  {
221  throw OomphLibError(
222  "No elasticity tensor set.",
223  OOMPH_CURRENT_FUNCTION,
224  OOMPH_EXCEPTION_LOCATION);
225  }
226 #endif
227 
228  //Find the indices at which the local displacements are stored
229  unsigned u_nodal_index[DIM];
230  for(unsigned i=0;i<DIM;i++)
231  {u_nodal_index[i] = this->u_index_linear_elasticity(i);}
232 
233  // Timescale ratio (non-dim density)
234  double Lambda_sq = this->lambda_sq();
235 
236  //Set up memory for the shape functions
237  Shape psi(n_node);
238  DShape dpsidx(n_node,DIM);
239 
240  //Set the value of Nintpt -- the number of integration points
241  unsigned n_intpt = this->integral_pt()->nweight();
242 
243  //Set the vector to hold the local coordinates in the element
244  Vector<double> s(DIM);
245 
246  //Integer to store the local equation number
247  int local_eqn=0, local_unknown=0;
248 
249  //Loop over the integration points
250  for(unsigned ipt=0;ipt<n_intpt;ipt++)
251  {
252  //Assign the values of s
253  for(unsigned i=0;i<DIM;++i) {s[i] = this->integral_pt()->knot(ipt,i);}
254 
255  //Get the integral weight
256  double w = this->integral_pt()->weight(ipt);
257 
258  //Call the derivatives of the shape functions (and get Jacobian)
259  double J = this->dshape_eulerian_at_knot(ipt,psi,dpsidx);
260 
261  //Storage for Eulerian coordinates (initialised to zero)
262  Vector<double> interpolated_x(DIM,0.0);
263 
264  //Calculate interpolated values of the derivative of global position
265  //wrt lagrangian coordinates
266  DenseMatrix<double> interpolated_dudx(DIM,DIM,0.0);
267 
268  // Setup memory for accelerations (initialised to zero)
269  Vector<double> accel(DIM,0.0);
270 
271  //Calculate displacements and derivatives and lagrangian coordinates
272  for(unsigned l=0;l<n_node;l++)
273  {
274  //Loop over displacement components (deformed position)
275  for(unsigned i=0;i<DIM;i++)
276  {
277  //Calculate the Lagrangian coordinates and the accelerations
278  interpolated_x[i] += this->raw_nodal_position(l,i)*psi(l);
279 
280  // Only compute accelerations if inertia is switched on
281  if(this->Unsteady)
282  {
283  accel[i] += this->d2u_dt2_linear_elasticity(l,i)*psi(l);
284  }
285 
286  //Get the nodal displacements
287  const double u_value = this->raw_nodal_value(l,u_nodal_index[i]);
288 
289  //Loop over derivative directions
290  for(unsigned j=0;j<DIM;j++)
291  {
292  interpolated_dudx(i,j) += u_value*dpsidx(l,j);
293  }
294  }
295  }
296 
297  //Get body force at current time
298  Vector<double> b(DIM);
299  this->body_force(interpolated_x,b);
300 
301  //Premultiply the weights and the Jacobian
302  double W = w*J;
303 
304 //=====EQUATIONS OF LINEAR ELASTICITY ========
305 
306  //Loop over the test functions, nodes of the element
307  for(unsigned l=0;l<n_node;l++)
308  {
309  //Loop over the displacement components
310  for(unsigned a=0;a<DIM;a++)
311  {
312  //Get the equation number
313  local_eqn = this->nodal_local_eqn(l,u_nodal_index[a]);
314  /*IF it's not a boundary condition*/
315  if(local_eqn >= 0)
316  {
317  // Acceleration and body force
318  residuals[local_eqn] +=
319  (Lambda_sq*accel[a]-b[a])*psi(l)*W;
320 
321  // Stress term
322  for(unsigned b=0;b<DIM;b++)
323  {
324  for(unsigned c=0;c<DIM;c++)
325  {
326  for(unsigned d=0;d<DIM;d++)
327  {
328  //Add the stress terms to the residuals
329  residuals[local_eqn] +=
330  this->E(a,b,c,d)*interpolated_dudx(c,d)*dpsidx(l,b)*W;
331  }
332  }
333  }
334 
335  //Jacobian entries
336  if(flag)
337  {
338  //Loop over the displacement basis functions again
339  for(unsigned l2=0;l2<n_node;l2++)
340  {
341  //Loop over the displacement components again
342  for(unsigned c=0;c<DIM;c++)
343  {
344  local_unknown = this->nodal_local_eqn(l2,u_nodal_index[c]);
345  //If it's not pinned
346  if(local_unknown >= 0)
347  {
348  // Inertial term
349  if (a==c)
350  {
351  jacobian(local_eqn,local_unknown) +=
352  Lambda_sq*
353  this->node_pt(l2)->time_stepper_pt()->weight(2,0)*
354  psi(l)*psi(l2)*W;
355  }
356 
357  for(unsigned b=0;b<DIM;b++)
358  {
359  for(unsigned d=0;d<DIM;d++)
360  {
361  //Add the contribution to the Jacobian matrix
362  jacobian(local_eqn,local_unknown) +=
363  this->E(a,b,c,d)*dpsidx(l2,d)*dpsidx(l,b)*W;
364  }
365  }
366  } //End of if not boundary condition
367 
368  }
369  }
370  } //End of jacobian calculation
371 
372  } //End of if not boundary condition
373  } //End of loop over coordinate directions
374  } //End of loop over shape functions
375  } //End of loop over integration points
376 
377  }
378 
379 
380 
381 
382 
383 //=======================================================================
384 /// Output exact solution x,y,[z],u,v,[w]
385 //=======================================================================
386  template <unsigned DIM>
387  void LinearElasticityEquations<DIM>::output_fct(std::ostream &outfile,
388  const unsigned &nplot,
390 {
391  //Vector of local coordinates
392  Vector<double> s(DIM);
393 
394  // Vector for coordintes
395  Vector<double> x(DIM);
396 
397  // Tecplot header info
398  outfile << this->tecplot_zone_string(nplot);
399 
400  // Exact solution Vector
401  Vector<double> exact_soln(DIM);
402 
403  // Loop over plot points
404  unsigned num_plot_points=this->nplot_points(nplot);
405  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
406  {
407 
408  // Get local coordinates of plot point
409  this->get_s_plot(iplot,nplot,s);
410 
411  // Get x position as Vector
412  this->interpolated_x(s,x);
413 
414  // Get exact solution at this point
415  (*exact_soln_pt)(x,exact_soln);
416 
417  //Output x,y,...,u_exact,...
418  for(unsigned i=0;i<DIM;i++)
419  {
420  outfile << x[i] << " ";
421  }
422  for(unsigned i=0;i<DIM;i++)
423  {
424  outfile << exact_soln[i] << " ";
425  }
426  outfile << std::endl;
427  }
428 
429  // Write tecplot footer (e.g. FE connectivity lists)
430  this->write_tecplot_zone_footer(outfile,nplot);
431 
432 }
433 
434 
435 
436 //=======================================================================
437 /// Output exact solution x,y,[z],u,v,[w] (unsteady version)
438 //=======================================================================
439  template <unsigned DIM>
440  void LinearElasticityEquations<DIM>::output_fct(std::ostream &outfile,
441  const unsigned &nplot,
442  const double &time,
444 {
445  //Vector of local coordinates
446  Vector<double> s(DIM);
447 
448  // Vector for coordintes
449  Vector<double> x(DIM);
450 
451  // Tecplot header info
452  outfile << this->tecplot_zone_string(nplot);
453 
454  // Exact solution Vector
455  Vector<double> exact_soln(DIM);
456 
457  // Loop over plot points
458  unsigned num_plot_points=this->nplot_points(nplot);
459  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
460  {
461 
462  // Get local coordinates of plot point
463  this->get_s_plot(iplot,nplot,s);
464 
465  // Get x position as Vector
466  this->interpolated_x(s,x);
467 
468  // Get exact solution at this point
469  (*exact_soln_pt)(time,x,exact_soln);
470 
471  //Output x,y,...,u_exact,...
472  for(unsigned i=0;i<DIM;i++)
473  {
474  outfile << x[i] << " ";
475  }
476  for(unsigned i=0;i<DIM;i++)
477  {
478  outfile << exact_soln[i] << " ";
479  }
480  outfile << std::endl;
481  }
482 
483  // Write tecplot footer (e.g. FE connectivity lists)
484  this->write_tecplot_zone_footer(outfile,nplot);
485 
486 }
487 
488 
489 
490 //=======================================================================
491 /// Output: x,y,[z],u,v,[w]
492 //=======================================================================
493  template <unsigned DIM>
494  void LinearElasticityEquations<DIM>::output(std::ostream &outfile,
495  const unsigned &nplot)
496  {
497  //Set output Vector
498  Vector<double> s(DIM);
499  Vector<double> x(DIM);
500  Vector<double> u(DIM);
501 
502  // Tecplot header info
503  outfile << this->tecplot_zone_string(nplot);
504 
505  // Loop over plot points
506  unsigned num_plot_points=this->nplot_points(nplot);
507  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
508  {
509 
510  // Get local coordinates of plot point
511  this->get_s_plot(iplot,nplot,s);
512 
513  // Get Eulerian coordinates and displacements
514  this->interpolated_x(s,x);
515  this->interpolated_u_linear_elasticity(s,u);
516 
517  //Output the x,y,..
518  for(unsigned i=0;i<DIM;i++)
519  {outfile << x[i] << " ";}
520 
521  // Output u,v,..
522  for(unsigned i=0;i<DIM;i++)
523  {outfile << u[i] << " ";}
524 
525  outfile << std::endl;
526  }
527 
528  // Write tecplot footer (e.g. FE connectivity lists)
529  this->write_tecplot_zone_footer(outfile,nplot);
530  }
531 
532 
533 
534 
535 //=======================================================================
536 /// C-style output: x,y,[z],u,v,[w]
537 //=======================================================================
538 template <unsigned DIM>
540  const unsigned &nplot)
541 {
542  //Vector of local coordinates
543  Vector<double> s(DIM);
544 
545  // Tecplot header info
546  fprintf(file_pt,"%s",this->tecplot_zone_string(nplot).c_str());
547 
548  // Loop over plot points
549  unsigned num_plot_points=this->nplot_points(nplot);
550  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
551  {
552  // Get local coordinates of plot point
553  this->get_s_plot(iplot,nplot,s);
554 
555  // Coordinates
556  for(unsigned i=0;i<DIM;i++)
557  {
558  fprintf(file_pt,"%g ",this->interpolated_x(s,i));
559  }
560 
561  // Displacement
562  for(unsigned i=0;i<DIM;i++)
563  {
564  fprintf(file_pt,"%g ",this->interpolated_u_linear_elasticity(s,i));
565  }
566  }
567  fprintf(file_pt,"\n");
568 
569  // Write tecplot footer (e.g. FE connectivity lists)
570  this->write_tecplot_zone_footer(file_pt,nplot);
571 
572 }
573 
574 
575 //======================================================================
576 /// Validate against exact velocity solution
577 /// Solution is provided via function pointer.
578 /// Plot at a given number of plot points and compute L2 error
579 /// and L2 norm of velocity solution over element.
580 //=======================================================================
581 template<unsigned DIM>
583  std::ostream &outfile,
585  double& error, double& norm)
586 {
587 
588  error=0.0;
589  norm=0.0;
590 
591  //Vector of local coordinates
592  Vector<double> s(DIM);
593 
594  // Vector for coordinates
595  Vector<double> x(DIM);
596 
597  //Set the value of n_intpt
598  unsigned n_intpt = this->integral_pt()->nweight();
599 
600  outfile << "ZONE" << std::endl;
601 
602  // Exact solution Vector (u,v,[w])
603  Vector<double> exact_soln(DIM);
604 
605  //Loop over the integration points
606  for(unsigned ipt=0;ipt<n_intpt;ipt++)
607  {
608 
609  //Assign values of s
610  for(unsigned i=0;i<DIM;i++)
611  {
612  s[i] = this->integral_pt()->knot(ipt,i);
613  }
614 
615  //Get the integral weight
616  double w = this->integral_pt()->weight(ipt);
617 
618  // Get jacobian of mapping
619  double J=this->J_eulerian(s);
620 
621  //Premultiply the weights and the Jacobian
622  double W = w*J;
623 
624  // Get x position as Vector
625  this->interpolated_x(s,x);
626 
627  // Get exact solution at this point
628  (*exact_soln_pt)(x,exact_soln);
629 
630  // Displacement error
631  for(unsigned i=0;i<DIM;i++)
632  {
633  norm+=exact_soln[i]*exact_soln[i]*W;
634  error+=(exact_soln[i]-this->interpolated_u_linear_elasticity(s,i))*
635  (exact_soln[i]-this->interpolated_u_linear_elasticity(s,i))*W;
636  }
637 
638  //Output x,y,[z]
639  for(unsigned i=0;i<DIM;i++)
640  {
641  outfile << x[i] << " ";
642  }
643 
644  //Output u_error,v_error,[w_error]
645  for(unsigned i=0;i<DIM;i++)
646  {
647  outfile << exact_soln[i]-this->interpolated_u_linear_elasticity(s,i)
648  << " ";
649  }
650  outfile << std::endl;
651  }
652 }
653 
654 //======================================================================
655 /// Validate against exact velocity solution
656 /// Solution is provided via function pointer.
657 /// Plot at a given number of plot points and compute L2 error
658 /// and L2 norm of velocity solution over element. Unsteady version
659 //=======================================================================
660 template<unsigned DIM>
662  std::ostream &outfile,
664  const double& time, double& error, double& norm)
665 {
666 
667  error=0.0;
668  norm=0.0;
669 
670  //Vector of local coordinates
671  Vector<double> s(DIM);
672 
673  // Vector for coordinates
674  Vector<double> x(DIM);
675 
676  //Set the value of n_intpt
677  unsigned n_intpt = this->integral_pt()->nweight();
678 
679  outfile << "ZONE" << std::endl;
680 
681  // Exact solution Vector (u,v,[w])
682  Vector<double> exact_soln(DIM);
683 
684  //Loop over the integration points
685  for(unsigned ipt=0;ipt<n_intpt;ipt++)
686  {
687 
688  //Assign values of s
689  for(unsigned i=0;i<DIM;i++)
690  {
691  s[i] = this->integral_pt()->knot(ipt,i);
692  }
693 
694  //Get the integral weight
695  double w = this->integral_pt()->weight(ipt);
696 
697  // Get jacobian of mapping
698  double J=this->J_eulerian(s);
699 
700  //Premultiply the weights and the Jacobian
701  double W = w*J;
702 
703  // Get x position as Vector
704  this->interpolated_x(s,x);
705 
706  // Get exact solution at this point
707  (*exact_soln_pt)(time,x,exact_soln);
708 
709  // Displacement error
710  for(unsigned i=0;i<DIM;i++)
711  {
712  norm+=exact_soln[i]*exact_soln[i]*W;
713  error+=(exact_soln[i]-this->interpolated_u_linear_elasticity(s,i))*
714  (exact_soln[i]-this->interpolated_u_linear_elasticity(s,i))*W;
715  }
716 
717  //Output x,y,[z]
718  for(unsigned i=0;i<DIM;i++)
719  {
720  outfile << x[i] << " ";
721  }
722 
723  //Output u_error,v_error,[w_error]
724  for(unsigned i=0;i<DIM;i++)
725  {
726  outfile << exact_soln[i]-this->interpolated_u_linear_elasticity(s,i)
727  << " ";
728  }
729  outfile << std::endl;
730  }
731 }
732 
733 
734 //Instantiate the required elements
735 template class LinearElasticityEquationsBase<2>;
736 template class LinearElasticityEquations<2>;
737 
738 template class QLinearElasticityElement<3,3>;
739 template class LinearElasticityEquationsBase<3>;
740 template class LinearElasticityEquations<3>;
741 
742 
743 
744 }
virtual void fill_in_generic_contribution_to_residuals_linear_elasticity(Vector< double > &residuals, DenseMatrix< double > &jacobian, unsigned flag)
Private helper function to compute residuals and (if requested via flag) also the Jacobian matrix...
cstr elem_len * i
Definition: cfortran.h:607
void compute_error(std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
Validate against exact solution. Solution is provided via function pointer. Plot at a given number of...
unsigned long nrow() const
Return the number of rows of the matrix.
Definition: matrices.h:504
void get_stress(const Vector< double > &s, DenseMatrix< double > &sigma) const
Return the Cauchy stress tensor, as calculated from the elasticity tensor at specified local coordina...
void output_fct(std::ostream &outfile, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
Output exact solution x,y,[z],u,v,[w].
static char t char * s
Definition: cfortran.h:572
unsigned long ncol() const
Return the number of columns of the matrix.
Definition: matrices.h:507
void(* SteadyExactSolutionFctPt)(const Vector< double > &, Vector< double > &)
Function pointer for function that computes vector-valued steady "exact solution" as ...
Definition: elements.h:1720
void(* UnsteadyExactSolutionFctPt)(const double &, const Vector< double > &, Vector< double > &)
Function pointer for function that computes Vector-valued time-dependent function as ...
Definition: elements.h:1726
void output(std::ostream &outfile)
Output: x,y,[z],u,v,[w].
void get_strain(const Vector< double > &s, DenseMatrix< double > &strain) const
Return the strain tensor.