elastic_problems.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 
31 #include "problem.h"
32 #include "fsi.h"
33 #include "elastic_problems.h"
34 
35 
36 namespace oomph
37 {
38 
39 
40 //////////////////////////////////////////////////////////////////////////
41 //////////////////////////////////////////////////////////////////////////
42 //////////////////////////////////////////////////////////////////////////
43 
44 
45 //======================================================================
46 /// Setup IC problem by:
47 /// - Pinning all nodal values in the mesh
48 /// - Pinning the internal data of all elements.
49 /// - Freeing/unpinnning all positional data.
50 /// - Flushing the pointers to the elements' external data.
51 /// - Setting the pointer to the IC object for all elements to
52 /// ensure that the correct residuals/Jacobians are computed.
53 //======================================================================
55 {
56 
57  //Find out how many nodes there are
58  unsigned long n_node = mesh_pt()->nnode();
59 
60  //Loop over all the nodes
61  for(unsigned n=0;n<n_node;n++)
62  {
63  // Cast to an elastic node
64  SolidNode* node_pt=dynamic_cast<SolidNode*>(mesh_pt()->node_pt(n));
65 
66 #ifdef PARANOID
67  if (node_pt==0)
68  {
69  throw OomphLibError("Wasn't able to cast to SolidNode\n",
70  OOMPH_CURRENT_FUNCTION,
71  OOMPH_EXCEPTION_LOCATION);
72  }
73 #endif
74 
75  // Get spatial dimension of node
76  unsigned ndim=node_pt->ndim();
77 
78  //Find out how many positional dofs there are
79  SolidFiniteElement* elem_pt=
80  dynamic_cast<SolidFiniteElement*>(mesh_pt()->element_pt(0));
81 
82 #ifdef PARANOID
83  if (elem_pt==0)
84  {
85  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
86  OOMPH_CURRENT_FUNCTION,
87  OOMPH_EXCEPTION_LOCATION);
88  }
89 #endif
90 
91  unsigned ntype = elem_pt->nnodal_position_type();
92 
93  //Loop over coordinate directions
94  for(unsigned i=0;i<ndim;i++)
95  {
96  //Loop over type of dof
97  for(unsigned k=0;k<ntype;k++)
98  {
99  // Unpin them
100  node_pt->unpin_position(k,i);
101  }
102  }
103 
104  // Loop over nodal values
105  unsigned nval=node_pt->nvalue();
106  for (unsigned ival=0;ival<nval;ival++)
107  {
108  // Pin them
109  node_pt->pin(ival);
110  }
111  }
112 
113 
114 // Loop over the elements
115  unsigned Nelement=mesh_pt()->nelement();
116  for(unsigned i=0;i<Nelement;i++)
117  {
118 
119  //Cast to proper element type
120  SolidFiniteElement* elem_pt = dynamic_cast<SolidFiniteElement*>(
121  mesh_pt()->element_pt(i));
122 
123 #ifdef PARANOID
124  if (elem_pt==0)
125  {
126  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
127  OOMPH_CURRENT_FUNCTION,
128  OOMPH_EXCEPTION_LOCATION);
129  }
130 #endif
131 
132 
133  // Set flag for setting initial condition
134  elem_pt->solid_ic_pt() = IC_pt;
135 
136  // We've backed up the element's external data: Flush it
137  elem_pt->flush_external_data();
138 
139  //IF it's an FSI wall element then kill external stuff
140  if(FSIWallElement* fsi_elem_pt = dynamic_cast<FSIWallElement*>(elem_pt))
141  {
142  fsi_elem_pt->exclude_external_load_data();
143  }
144 
145  // Find out number of internal data
146  unsigned nint=elem_pt->ninternal_data();
147 
148  // Loop over internal data
149  for (unsigned j=0;j<nint;j++)
150  {
151  Data* data_pt=elem_pt->internal_data_pt(j);
152 
153  // Loop over internal values
154  unsigned nval=data_pt->nvalue();
155  for (unsigned ival=0;ival<nval;ival++)
156  {
157  // Pin internal values
158  data_pt->pin(ival);
159  }
160  }
161 
162 #ifdef PARANOID
163  //Is there internal solid data
164  if (elem_pt->has_internal_solid_data())
165  {
166  std::string error_message =
167  "Automatic assignment of initial conditions doesn't work yet\n";
168  error_message +=
169  "for elasticity elements with internal solid dofs (pressures)\n";
170 
171  throw OomphLibError(error_message,
172  OOMPH_CURRENT_FUNCTION,
173  OOMPH_EXCEPTION_LOCATION);
174  }
175 #endif
176 // for(unsigned i=0;i<nint_solid;i++)
177 // {
178 // Data* data_pt=elem_pt->internal_solid_data_pt(i);
179 
180 // // Loop over values
181 // unsigned nval=data_pt->nvalue();
182 // for (unsigned ival=0;ival<nval;ival++)
183 // {
184 // // Pin internal values
185 // data_pt->pin(ival);
186 // }
187 // }
188 
189  }
190 
191  // Setup equation numbers for IC problem
192  oomph_info << "# of dofs for wall initial guess"
193  << assign_eqn_numbers() << std::endl;
194 
195 }
196 
197 
198 
199 //======================================================================
200 /// Backup pinned status of all data associated with the mesh.
201 /// Also backup the (pointers to the) elements' external data.
202 //======================================================================
204 {
205 
206  //Find out how many nodes there are
207  unsigned long n_node = mesh_pt()->nnode();
208 
209  // Flush vector which holds backup of pinned status
210  Backup_pinned.clear();
211 
212  // Flush vector which holds vectors with backup of (pointers to) external data
213  Backup_ext_data.clear();
214 
215  //Loop over all the nodes
216  for(unsigned n=0;n<n_node;n++)
217  {
218  // Cast to an elastic node
219  SolidNode* node_pt=dynamic_cast<SolidNode*>(mesh_pt()->node_pt(n));
220 
221 #ifdef PARANOID
222  if (node_pt==0)
223  {
224  throw OomphLibError("Wasn't able to cast to SolidNode\n",
225  OOMPH_CURRENT_FUNCTION,
226  OOMPH_EXCEPTION_LOCATION);
227  }
228 #endif
229 
230  // Get spatial dimension of node
231  unsigned ndim=node_pt->ndim();
232 
233  //Find out how many positional dofs there are
234  SolidFiniteElement* elem_pt=
235  dynamic_cast<SolidFiniteElement*>(mesh_pt()->element_pt(0));
236 
237 #ifdef PARANOID
238  if (elem_pt==0)
239  {
240  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
241  OOMPH_CURRENT_FUNCTION,
242  OOMPH_EXCEPTION_LOCATION);
243  }
244 #endif
245 
246  unsigned ntype = elem_pt->nnodal_position_type();
247 
248 
249  //Loop over coordinate directions
250  for(unsigned i=0;i<ndim;i++)
251  {
252  //Loop over type of dof
253  for(unsigned k=0;k<ntype;k++)
254  {
255  // Backup pinned status
256  Backup_pinned.push_back(node_pt->position_is_pinned(k,i));
257  }
258  }
259 
260  // Loop over nodal values
261  unsigned nval=node_pt->nvalue();
262  for (unsigned ival=0;ival<nval;ival++)
263  {
264  // Backup pinned status
265  Backup_pinned.push_back(node_pt->is_pinned(ival));
266  }
267  }
268 
269  // Loop over the elements
270  unsigned Nelement=mesh_pt()->nelement();
271  Backup_ext_data.resize(Nelement);
272  for(unsigned i=0;i<Nelement;i++)
273  {
274  //Cast to proper element type
275  SolidFiniteElement* elem_pt = dynamic_cast<SolidFiniteElement*>(
276  mesh_pt()->element_pt(i));
277 
278 #ifdef PARANOID
279  if (elem_pt==0)
280  {
281  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
282  OOMPH_CURRENT_FUNCTION,
283  OOMPH_EXCEPTION_LOCATION);
284  }
285 #endif
286 
287  // Find out number of external data
288  unsigned next=elem_pt->nexternal_data();
289  Backup_ext_data[i].resize(next);
290 
291  // Loop over external data
292  for (unsigned j=0;j<next;j++)
293  {
294  Data* data_pt=elem_pt->external_data_pt(j);
295 
296  // Backup the pointer to external data
297  Backup_ext_data[i][j]=data_pt;
298  }
299 
300  // Find out number of internal data
301  unsigned nint=elem_pt->ninternal_data();
302 
303  // Loop over internal data
304  for (unsigned j=0;j<nint;j++)
305  {
306  Data* data_pt=elem_pt->internal_data_pt(j);
307 
308  // Loop over internal values
309  unsigned nval=data_pt->nvalue();
310  for (unsigned ival=0;ival<nval;ival++)
311  {
312  // Backup pinned status
313  Backup_pinned.push_back(data_pt->is_pinned(ival));
314  }
315  }
316 
317 
318 #ifdef PARANOID
319  //If there is internal solid data, complain
320  if (elem_pt->has_internal_solid_data())
321  {
322  std::string error_message =
323  "Automatic assignment of initial conditions doesn't work yet\n";
324  error_message +=
325  "for elasticity elements with internal solid dofs (pressures)\n";
326 
327  throw OomphLibError(error_message,
328  OOMPH_CURRENT_FUNCTION,
329  OOMPH_EXCEPTION_LOCATION);
330  }
331 #endif
332 // for(unsigned i=0;i<nint_solid;i++)
333 // {
334 // Data* data_pt=elem_pt->internal_solid_data_pt(i);
335 
336 // // Loop over values
337 // unsigned nval=data_pt->nvalue();
338 // for (unsigned ival=0;ival<nval;ival++)
339 // {
340 // // Backup pinned status
341 // Backup_pinned.push_back(data_pt->is_pinned(ival));
342 // }
343 // }
344 
345  }
346 
347  // Record number of dofs whose status was pinned
348  //oomph_info << "Number of backed up values " << Backup_pinned.size() << std::endl;
349 
350 }
351 
352 
353 
354 
355 //======================================================================
356 /// Reset pinned status of all data and re-instate the pointers
357 /// to the elements' external data.
358 //======================================================================
360 {
361 
362  //Find out how many nodes there are
363  unsigned long n_node = mesh_pt()->nnode();
364 
365  // Initialise counter for backed up dofs
366  unsigned count=0;
367 
368  //Loop over all the nodes
369  for(unsigned n=0;n<n_node;n++)
370  {
371  // Cast to an elastic node
372  SolidNode* node_pt=dynamic_cast<SolidNode*>(mesh_pt()->node_pt(n));
373 
374 #ifdef PARANOID
375  if (node_pt==0)
376  {
377  throw OomphLibError("Wasn't able to cast to SolidNode\n",
378  OOMPH_CURRENT_FUNCTION,
379  OOMPH_EXCEPTION_LOCATION);
380  }
381 #endif
382 
383  // Get spatial dimension of node
384  unsigned ndim=node_pt->ndim();
385 
386  //Find out how many positional dofs there are
387  SolidFiniteElement* elem_pt=
388  dynamic_cast<SolidFiniteElement*>(mesh_pt()->element_pt(0));
389 
390 #ifdef PARANOID
391  if (elem_pt==0)
392  {
393  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
394  OOMPH_CURRENT_FUNCTION,
395  OOMPH_EXCEPTION_LOCATION);
396  }
397 #endif
398 
399  unsigned ntype = elem_pt->nnodal_position_type();
400 
401  //Loop over coordinate directions
402  for(unsigned i=0;i<ndim;i++)
403  {
404  //Loop over type of dof
405  for(unsigned k=0;k<ntype;k++)
406  {
407  // Reset pinned status (positional dofs were all unpinned)
408  if (Backup_pinned[count])
409  {
410  node_pt->pin_position(k,i);
411  }
412  count++;
413  }
414  }
415 
416  // Loop over nodal values
417  unsigned nval=node_pt->nvalue();
418  for (unsigned ival=0;ival<nval;ival++)
419  {
420  // Reset pinned status (nodal values were all pinned)
421  if (Backup_pinned[count])
422  {
423  node_pt->unpin(ival);
424  }
425  }
426  }
427 
428 
429  // Loop over the elements
430  unsigned Nelement=mesh_pt()->nelement();
431  for(unsigned i=0;i<Nelement;i++)
432  {
433 
434  //Cast to proper element type
435  SolidFiniteElement *elem_pt = dynamic_cast<SolidFiniteElement*>(
436  mesh_pt()->element_pt(i));
437 
438 #ifdef PARANOID
439  if (elem_pt==0)
440  {
441  throw OomphLibError("Wasn't able to cast to SolidFiniteElement\n",
442  OOMPH_CURRENT_FUNCTION,
443  OOMPH_EXCEPTION_LOCATION);
444  }
445 #endif
446 
447  // Switch back to normal Jacobian
448  dynamic_cast<SolidFiniteElement*>(elem_pt)->
449  disable_solve_for_consistent_newmark_accel();
450 
451  // Switch off flag for setting initial condition
452  dynamic_cast<SolidFiniteElement*>(elem_pt)->solid_ic_pt() = 0;
453 
454  //IF it's an FSI wall element then turn on external stuff again
455  if(FSIWallElement* fsi_elem_pt = dynamic_cast<FSIWallElement*>(elem_pt))
456  {
457  fsi_elem_pt->include_external_load_data();
458  }
459 
460  // Find out number of external data
461  unsigned next=Backup_ext_data[i].size();
462 
463  // Loop over external data
464  for (unsigned j=0;j<next;j++)
465  {
466  // Backed up external data
467  Data* data_pt=Backup_ext_data[i][j];
468 
469  // Add external data
470  elem_pt->add_external_data(data_pt);
471  }
472 
473  // Find out number of internal data
474  unsigned nint=elem_pt->ninternal_data();
475 
476  // Loop over internal data
477  for (unsigned j=0;j<nint;j++)
478  {
479  Data* data_pt=elem_pt->internal_data_pt(j);
480 
481  // Loop over internal values
482  unsigned nval=data_pt->nvalue();
483  for (unsigned ival=0;ival<nval;ival++)
484  {
485  // Restore pinned status (values were all pinned)
486  if (!Backup_pinned[count])
487  {
488  data_pt->unpin(ival);
489  }
490  }
491  }
492 
493 
494 #ifdef PARANOID
495  //If there is internal solid data, complain
496  if (elem_pt->has_internal_solid_data())
497  {
498  std::string error_message =
499  "Automatic assignment of initial conditions doesn't work yet\n";
500  error_message +=
501  "for elasticity elements with internal solid dofs (pressures)\n";
502 
503  throw OomphLibError(error_message,
504  OOMPH_CURRENT_FUNCTION,
505  OOMPH_EXCEPTION_LOCATION);
506  }
507 #endif
508 // for(unsigned i=0;i<nint_solid;i++)
509 // {
510 // Data* data_pt=elem_pt->internal_solid_data_pt(i);
511 
512 // // Loop over values
513 // unsigned nval=data_pt->nvalue();
514 // for (unsigned ival=0;ival<nval;ival++)
515 // {
516 // // Restore pinned status (values were all pinned)
517 // if (!Backup_pinned[count])
518 // {
519 // data_pt->unpin(ival);
520 // }
521 // }
522 // }
523 
524  }
525 
526  // Check number of recovered pinned values
527  //oomph_info << "Recovered pin values " << count << std::endl;
528 
529  // Flush vector which holds backup of pinned status
530  Backup_pinned.clear();
531 
532  // Flush vector which holds vectors with backup of (pointers to) external data
533  Backup_ext_data.clear();
534 
535 }
536 
537 
538 //======================================================================
539 /// IC problem for wall: Deform wall into the static initial shape
540 /// described by the IC object at given time.
541 //======================================================================
543  Mesh* wall_mesh_pt,
544  SolidInitialCondition* ic_pt,
545  const double& time)
546 {
547  // Tell this sub-problem it is distributed if the main problem is distributed
548 #ifdef OOMPH_HAS_MPI
549  if (problem_pt->problem_has_been_distributed())
550  {
552  }
553  // This (sub-)problem needs to know about the oomph communicator
554  delete Communicator_pt;
556 #endif
557 
558 
559  // Backup value of time
560  double backup_time=0.0;
561 
562  // Set value of time for IC object (needs to be backed up and
563  // restored since it might be pointed to by other objects)
564  TimeStepper* timestepper_pt=ic_pt->geom_object_pt()->time_stepper_pt();
565  if (timestepper_pt!=0)
566  {
567  backup_time=timestepper_pt->time_pt()->time();
568  timestepper_pt->time_pt()->time()=time;
569  }
570 
571  // Delete dummy mesh
572  delete mesh_pt();
573 
574  // Set pointer to mesh
575  mesh_pt()=wall_mesh_pt;
576 
577  // Set pointer to initial condition object
578  IC_pt=ic_pt;
579 
580  // Backup the pinned status of all dofs and remove external data
581  // of all elements
583 
584  // Now alter the pinned status so that the IC problem for the
585  // positional variables can be solved; setup equation numbering
586  // scheme
587  setup_problem();
588 
589  // Assign displacements
590  IC_pt->ic_time_deriv()=0;
591 
592  // Solve the problem for initial shape
593  newton_solve();
594 
595  // Impulsive start
597 
598  // Reset the pinned status and re-attach the external data to the elements
600 
601  // Reset time
602  if (timestepper_pt!=0)
603  {
604  timestepper_pt->time_pt()->time()=backup_time;
605  }
606 
607  // Set pointer to dummy mesh so there's something that can be deleted
608  // when static problem finally goes out of scope.
609  mesh_pt()=new DummyMesh;
610 
611  // We have temporarily over-written equation numbers -- need
612  // to reset them now
613  oomph_info << "Number of equations in big problem: "
614  << problem_pt->assign_eqn_numbers() << std::endl;
615 }
616 
617 }
void unpin(const unsigned &i)
Unpin the i-th stored variable.
Definition: nodes.h:386
void newton_solve()
Use Newton method to solve the problem.
Definition: problem.cc:8741
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
bool is_pinned(const unsigned &i) const
Test whether the i-th variable is pinned (1: true; 0: false).
Definition: nodes.h:403
A class to specify the initial conditions for a solid body. Solid bodies are often discretised with H...
Definition: elements.h:3244
unsigned long nnode() const
Return number of nodes in the mesh.
Definition: mesh.h:590
unsigned & ic_time_deriv()
Which time derivative are we currently assigning?
Definition: elements.h:3275
void unpin_position(const unsigned &i)
Unpin the nodal position.
Definition: nodes.h:1702
SolidInitialCondition *& solid_ic_pt()
Pointer to object that describes the initial condition.
Definition: elements.h:3686
GeomObject *& geom_object_pt()
(Reference to) pointer to geom object that specifies the initial condition
Definition: elements.h:3269
cstr elem_len * i
Definition: cfortran.h:607
The Problem class.
Definition: problem.h:152
unsigned nnodal_position_type() const
Return the number of coordinate types that the element requires to interpolate the geometry between t...
Definition: elements.h:2340
Mesh *& mesh_pt()
Return a pointer to the global mesh.
Definition: problem.h:1264
OomphInfo oomph_info
Dummy mesh that can be created and deleted in SolidICProblem.
OomphCommunicator * communicator_pt()
access function to the oomph-lib communicator
Definition: problem.h:1221
unsigned nvalue() const
Return number of values stored in data object (incl pinned ones).
Definition: nodes.h:448
void pin(const unsigned &i)
Pin the i-th stored variable.
Definition: nodes.h:383
unsigned add_external_data(Data *const &data_pt, const bool &fd=true)
Definition: elements.cc:293
void flush_external_data()
Flush all external data.
Definition: elements.cc:365
unsigned long nelement() const
Return number of elements in the mesh.
Definition: mesh.h:587
void backup_original_state()
Backup original state of all data associated with mesh.
TimeStepper *& time_stepper_pt()
Access function for pointer to time stepper: Null if object is not time-dependent.
Definition: geom_objects.h:197
virtual bool has_internal_solid_data()
Return whether there is internal solid data (e.g. discontinuous solid pressure). At present...
Definition: elements.h:3334
void pin_position(const unsigned &i)
Pin the nodal position.
Definition: nodes.h:1693
void assign_initial_values_impulsive()
Initialise data and nodal positions to simulate impulsive start from initial configuration/solution.
Definition: problem.cc:11346
void reset_original_state()
Reset original state of all data associated with mesh.
OomphCommunicator * Communicator_pt
The communicator for this problem.
Definition: problem.h:1216
GeneralisedElement *& element_pt(const unsigned long &e)
Return pointer to element e.
Definition: mesh.h:462
Time *const & time_pt() const
Access function for the pointer to time (const version)
Definition: timesteppers.h:540
Data *& internal_data_pt(const unsigned &i)
Return a pointer to i-th internal data object.
Definition: elements.h:623
void set_static_initial_condition(Problem *problem_pt, Mesh *mesh_pt, SolidInitialCondition *ic_pt, const double &time)
Force the elastic structure that is discretised on the specified mesh to deform in the shape of the i...
A class that represents a collection of data; each Data object may contain many different individual ...
Definition: nodes.h:89
SolidInitialCondition * IC_pt
Pointer to initial condition object.
double & time()
Return the current value of the continuous time.
Definition: timesteppers.h:130
Node *& node_pt(const unsigned long &n)
Return pointer to global node n.
Definition: mesh.h:456
Data *& external_data_pt(const unsigned &i)
Return a pointer to i-th external data object.
Definition: elements.h:662
unsigned ninternal_data() const
Return the number of internal data objects.
Definition: elements.h:828
A Class for nodes that deform elastically (i.e. position is an unknown in the problem). The idea is that the Eulerian positions are stored in a Data object and the Lagrangian coordinates are stored in addition. The pointer that addresses the Eulerian positions is set to the pointer to Value in the Data object. Hence, SolidNode uses knowledge of the internal structure of Data and must be a friend of the Data class. In order to allow a mesh to deform via an elastic-style equation in deforming-domain problems, the positions are stored separately from the values, so that elastic problems may be combined with any other type of problem.
Definition: nodes.h:1568
std::string string(const unsigned &i)
Return the i-th string or "" if the relevant string hasn't been defined.
Vector< int > Backup_pinned
Vector to store pinned status of all data.
unsigned long assign_eqn_numbers(const bool &assign_local_eqn_numbers=true)
Assign all equation numbers for problem: Deals with global data (= data that isn't attached to any el...
Definition: problem.cc:1965
Vector< Vector< Data * > > Backup_ext_data
Vector of Vectors to store pointers to exernal data in the elements.
unsigned ndim() const
Return (Eulerian) spatial dimension of the node.
Definition: nodes.h:992
bool problem_has_been_distributed()
Access to Problem_has_been_distributed flag.
Definition: problem.h:2056
bool position_is_pinned(const unsigned &i)
Test whether the i-th coordinate is pinned, 0: false; 1: true.
Definition: nodes.h:1684
unsigned nexternal_data() const
Return the number of external data objects.
Definition: elements.h:831
Base class for time-stepping schemes. Timestepper provides an approximation of the temporal derivativ...
Definition: timesteppers.h:219
SolidFiniteElement class.
Definition: elements.h:3320
bool Problem_has_been_distributed
Has the problem been distributed amongst multiple processors?
Definition: problem.h:951
A general mesh class.
Definition: mesh.h:74
double & time()
Return the current value of continuous time.
Definition: problem.cc:11377
An oomph-lib wrapper to the MPI_Comm communicator object. Just contains an MPI_Comm object (which is ...
Definition: communicator.h:57