libMesh
Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Attributes | Friends | List of all members
Biharmonic Class Reference

The Biharmonic class encapsulates most of the data structures necessary to calculate the biharmonic residual and Jacobian, auxiliary quantities, to take a timestep, and to output the state – biharmonic solution and vectors of auxiliary quantities. More...

#include <biharmonic.h>

Inheritance diagram for Biharmonic:
[legend]

Classes

class  JR
 Biharmonic's friend class definition. More...
 

Public Types

enum  InitialStateEnum { STRIP = 0, ROD = 1, BALL = 2 }
 
enum  FreeEnergyEnum { DOUBLE_WELL = 1, DOUBLE_OBSTACLE = 2, LOG_DOUBLE_WELL = 3, LOG_DOUBLE_OBSTACLE = 4 }
 
enum  ReadFlags {
  READ_HEADER = 1, READ_DATA = 2, READ_ADDITIONAL_DATA = 4, READ_LEGACY_FORMAT = 8,
  TRY_READ_IFEMS = 16, READ_BASIC_ONLY = 32
}
 Define enumeration to set properties in EquationSystems::read() More...
 
enum  WriteFlags { WRITE_DATA = 1, WRITE_ADDITIONAL_DATA = 2, WRITE_PARALLEL_FILES = 4, WRITE_SERIAL_FILES = 8 }
 Define enumeration to set properties in EquationSystems::write() More...
 

Public Member Functions

 Biharmonic (ReplicatedMesh &mesh)
 Constructor retrieves command-line options, setting defaults, if necessary. More...
 
 ~Biharmonic ()
 Destructor. More...
 
bool verbose ()
 
Real dt0 ()
 
Real dt ()
 
void viewParameters ()
 
void init ()
 Initialize all the systems. More...
 
void step (const Real &dt=-1.0)
 
void output (int timestep, const Real &t, Real &o_t, bool force=false)
 
void run ()
 
virtual void clear ()
 Restores the data structure to a pristine state. More...
 
virtual void reinit ()
 Handle any mesh changes and reinitialize all the systems on the updated mesh. More...
 
virtual void reinit_mesh ()
 Handle the association of a completely new mesh with the EquationSystem and all the Systems assigned to it. More...
 
virtual void enable_default_ghosting (bool enable)
 Enable or disable default ghosting functors on the Mesh and on all Systems. More...
 
void update ()
 Updates local values for all the systems. More...
 
unsigned int n_systems () const
 
bool has_system (std::string_view name) const
 
template<typename T_sys >
const T_sys & get_system (std::string_view name) const
 
template<typename T_sys >
T_sys & get_system (std::string_view name)
 
template<typename T_sys >
const T_sys & get_system (const unsigned int num) const
 
template<typename T_sys >
T_sys & get_system (const unsigned int num)
 
const System & get_system (std::string_view name) const
 
System & get_system (std::string_view name)
 
const System & get_system (const unsigned int num) const
 
System & get_system (const unsigned int num)
 
virtual System & add_system (std::string_view system_type, std::string_view name)
 Add the system of type system_type named name to the systems array. More...
 
template<typename T_sys >
T_sys & add_system (std::string_view name)
 Add the system named name to the systems array. More...
 
unsigned int n_vars () const
 
std::size_t n_dofs () const
 
std::size_t n_active_dofs () const
 
virtual void solve ()
 Call solve on all the individual equation systems. More...
 
virtual void adjoint_solve (const QoISet &qoi_indices=QoISet())
 Call adjoint_solve on all the individual equation systems. More...
 
virtual void sensitivity_solve (const ParameterVector &parameters)
 Call sensitivity_solve on all the individual equation systems. More...
 
void build_variable_names (std::vector< std::string > &var_names, const FEType *type=nullptr, const std::set< std::string > *system_names=nullptr) const
 Fill the input vector var_names with the names of the variables for each system. More...
 
void build_solution_vector (std::vector< Number > &soln, std::string_view system_name, std::string_view variable_name="all_vars") const
 Fill the input vector soln with the solution values for the system named name. More...
 
void build_solution_vector (std::vector< Number > &soln, const std::set< std::string > *system_names=nullptr, bool add_sides=false) const
 Fill the input vector soln with solution values. More...
 
std::unique_ptr< NumericVector< Number > > build_parallel_solution_vector (const std::set< std::string > *system_names=nullptr, bool add_sides=false) const
 A version of build_solution_vector which is appropriate for "parallel" output formats like Nemesis. More...
 
void get_vars_active_subdomains (const std::vector< std::string > &names, std::vector< std::set< subdomain_id_type >> &vars_active_subdomains) const
 Retrieve vars_active_subdomains, which indicates the active subdomains for each variable in names. More...
 
void get_solution (std::vector< Number > &soln, std::vector< std::string > &names) const
 Retrieve the solution data for CONSTANT MONOMIALs and/or components of CONSTANT MONOMIAL_VECs. More...
 
void build_elemental_solution_vector (std::vector< Number > &soln, std::vector< std::string > &names) const
 Retrieve the solution data for CONSTANT MONOMIALs and/or components of CONSTANT MONOMIAL_VECs. More...
 
std::vector< std::pair< unsigned int, unsigned int > > find_variable_numbers (std::vector< std::string > &names, const FEType *type=nullptr, const std::vector< FEType > *types=nullptr) const
 Finds system and variable numbers for any variables of 'type' or of 'types' corresponding to the entries in the input 'names' vector. More...
 
std::unique_ptr< NumericVector< Number > > build_parallel_elemental_solution_vector (std::vector< std::string > &names) const
 Builds a parallel vector of CONSTANT MONOMIAL and/or components of CONSTANT MONOMIAL_VEC solution values corresponding to the entries in the input 'names' vector. More...
 
void build_discontinuous_solution_vector (std::vector< Number > &soln, const std::set< std::string > *system_names=nullptr, const std::vector< std::string > *var_names=nullptr, bool vertices_only=false, bool add_sides=false) const
 Fill the input vector soln with solution values. More...
 
template<typename InValType = Number>
void read (std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
 Read & initialize the systems from disk using the XDR data format. More...
 
template<typename InValType = Number>
void read (std::string_view name, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
 
template<typename InValType = Number>
void read (Xdr &io, std::function< std::unique_ptr< Xdr >()> &local_io_functor, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
 
void write (std::string_view name, const XdrMODE, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
 Write the systems to disk using the XDR data format. More...
 
void write (std::string_view name, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
 
void write (std::ostream name, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
 
void write (Xdr &io, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true, Xdr *const local_io=nullptr) const
 
virtual bool compare (const EquationSystems &other_es, const Real threshold, const bool verbose) const
 
virtual std::string get_info () const
 
void print_info (std::ostream &os=libMesh::out) const
 Prints information about the equation systems, by default to libMesh::out. More...
 
const MeshBase & get_mesh () const
 
MeshBase & get_mesh ()
 
void allgather ()
 Serializes a distributed mesh and its associated degree of freedom numbering for all systems. More...
 
void enable_refine_in_reinit ()
 Calls to reinit() will also do two-step coarsen-then-refine. More...
 
void disable_refine_in_reinit ()
 Calls to reinit() will not try to coarsen or refine the mesh. More...
 
bool refine_in_reinit_flag ()
 
bool reinit_solutions ()
 Handle any mesh changes and project any solutions onto the updated mesh. More...
 
virtual void reinit_systems ()
 Reinitialize all systems on the current mesh. More...
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static bool redundant_added_side (const Elem &elem, unsigned int side)
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
static void disable_print_counter_info ()
 

Public Attributes

Parameters parameters
 Data structure holding arbitrary parameters. More...
 

Protected Types

typedef std::map< std::string, std::pair< unsigned int, unsigned int > > Counts
 Data structure to log the information. More...
 

Protected Member Functions

void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Protected Attributes

std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
 Data structure holding the systems. More...
 
bool _refine_in_reinit
 Flag for whether to call coarsen/refine in reinit(). More...
 
bool _enable_default_ghosting
 Flag for whether to enable default ghosting on newly added Systems. More...
 
const Parallel::Communicator & _communicator
 

Static Protected Attributes

static Counts _counts
 Actually holds the data. More...
 
static Threads::atomic< unsigned int > _n_objects
 The number of objects. More...
 
static Threads::spin_mutex _mutex
 Mutual exclusion object to enable thread-safe reference counting. More...
 
static bool _enable_print_counter = true
 Flag to control whether reference count information is printed when print_info is called. More...
 

Private Attributes

unsigned int _dim
 
unsigned int _N
 
Real _kappa
 
Real _theta
 
Real _theta_c
 
Real _tol
 
bool _growth
 
bool _degenerate
 
bool _cahn_hillard
 
bool _netforce
 
FreeEnergyEnum _energy
 
int _log_truncation
 
bool _verbose
 
InitialStateEnum _initialState
 
Point _initialCenter
 
Real _initialWidth
 
Real _dt0
 
Real _dt
 
Real _t0
 
Real _T
 
Real _t1
 
Real _cnWeight
 
std::string _ofile_base
 
std::string _ofile
 
std::unique_ptr< ExodusII_IO > _exio
 
Real _o_dt
 
int _o_count
 
ReplicatedMesh & _mesh
 
JR * _jr
 

Friends

class JR
 

Detailed Description

The Biharmonic class encapsulates most of the data structures necessary to calculate the biharmonic residual and Jacobian, auxiliary quantities, to take a timestep, and to output the state – biharmonic solution and vectors of auxiliary quantities.

The main reason for this design is to have a data structure that has all of the necessary data in one place, where all of the calculation subroutines can access these data. Currently these data are split up among several interdependent objects with no clear hierarchy between them: mesh, equation system, equation system bundle, residual/Jacobian calculator.

Since no object contains all others and the data are distributed among many objects, the natural control and data flow resides outside of these objects and is typically implemented in main(). We, however, would like to split the calculation into natural chunks – subroutines – while retaining these subroutines access to the common necessary data – biharmonic parameters, mesh and time interval sizes, etc. Thus, class Biharmonic. Finally, making Biharmonic inherit from EquationSystems makes it possible to include it in the most common callbacks that do not pass back a user context, but only an EquationSystems object.

Definition at line 45 of file biharmonic.h.

Member Typedef Documentation

◆ Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts
protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

Member Enumeration Documentation

◆ FreeEnergyEnum

enum Biharmonic::FreeEnergyEnum
Enumerator
DOUBLE_WELL 
DOUBLE_OBSTACLE 
LOG_DOUBLE_WELL 
LOG_DOUBLE_OBSTACLE 

Definition at line 54 of file biharmonic.h.

54  {DOUBLE_WELL = 1,
55  DOUBLE_OBSTACLE = 2,
56  LOG_DOUBLE_WELL = 3,
57  LOG_DOUBLE_OBSTACLE = 4};

◆ InitialStateEnum

enum Biharmonic::InitialStateEnum
Enumerator
STRIP 
ROD 
BALL 

Definition at line 49 of file biharmonic.h.

49  {STRIP = 0,
50  ROD = 1,
51  BALL = 2};

◆ ReadFlags

enum libMesh::EquationSystems::ReadFlags
inherited

Define enumeration to set properties in EquationSystems::read()

Enumerator
READ_HEADER 
READ_DATA 
READ_ADDITIONAL_DATA 
READ_LEGACY_FORMAT 
TRY_READ_IFEMS 
READ_BASIC_ONLY 

Definition at line 77 of file equation_systems.h.

77  { READ_HEADER = 1,
78  READ_DATA = 2,
79  READ_ADDITIONAL_DATA = 4,
80  READ_LEGACY_FORMAT = 8,
81  TRY_READ_IFEMS = 16,
82  READ_BASIC_ONLY = 32 };

◆ WriteFlags

enum libMesh::EquationSystems::WriteFlags
inherited

Define enumeration to set properties in EquationSystems::write()

Enumerator
WRITE_DATA 
WRITE_ADDITIONAL_DATA 
WRITE_PARALLEL_FILES 
WRITE_SERIAL_FILES 

Definition at line 87 of file equation_systems.h.

87  { WRITE_DATA = 1,
88  WRITE_ADDITIONAL_DATA = 2,
89  WRITE_PARALLEL_FILES = 4,
90  WRITE_SERIAL_FILES = 8 };

Constructor & Destructor Documentation

◆ Biharmonic()

Biharmonic::Biharmonic ( ReplicatedMesh &  mesh)

Constructor retrieves command-line options, setting defaults, if necessary.

It then builds the mesh using these options, then the equations systems around it, and, finally, sets up the output. We recommend that this be used through the factory Create function, which allocates the mesh. In that case don't forget to call Destroy at the end, to free the mesh up.

Definition at line 16 of file biharmonic.C.

References _cahn_hillard, _cnWeight, _degenerate, _dim, _dt0, _energy, _exio, _growth, _initialCenter, _initialState, _initialWidth, _kappa, _log_truncation, _mesh, _N, _netforce, _o_dt, _ofile, _ofile_base, _T, _t0, _t1, _theta, _theta_c, _tol, _verbose, BALL, libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_line(), libMesh::MeshTools::Generation::build_square(), libMesh::command_line_value(), libMesh::command_line_vector(), DOUBLE_OBSTACLE, DOUBLE_WELL, libMesh::EDGE2, libMesh::HEX8, LOG_DOUBLE_OBSTACLE, LOG_DOUBLE_WELL, libMesh::on_command_line(), libMesh::out, libMesh::QUAD4, ROD, and STRIP.

16  :
17  EquationSystems(mesh),
18  _mesh(mesh)
19 {
20  // Retrieve parameters and set defaults
21  _verbose = false;
22  _growth = false;
23  _degenerate = false;
24  _cahn_hillard = false;
25  _netforce = false;
26 
27  if (on_command_line("--verbose"))
28  _verbose = true;
29  if (on_command_line("--growth"))
30  _growth = true;
31  if (on_command_line("--degenerate"))
32  _degenerate = true;
33  if (on_command_line("--cahn_hillard"))
34  _cahn_hillard = true;
35  if (on_command_line("--netforce"))
36  _netforce = true;
37 
38  _kappa = command_line_value("kappa", 1.0);
39 
40  // "type of energy (double well, double obstacle, logarithmic+double well, logarithmic+double obstacle)"
41  std::string energy = command_line_value("energy", std::string("double_well"));
42 
43  if (energy == "double_well")
44  _energy = DOUBLE_WELL;
45  else if (energy == "double_obstacle")
46  _energy = DOUBLE_OBSTACLE;
47  else if (energy == "log_double_well")
48  _energy = LOG_DOUBLE_WELL;
49  else if (energy == "log_double_obstacle")
50  _energy = LOG_DOUBLE_OBSTACLE;
51  else
52  libmesh_error_msg("Unknown energy type: " << energy);
53 
54  _tol = command_line_value("tol", 1.0e-8);
55  _theta = command_line_value("theta", .001);
56  _theta_c = command_line_value("theta_c", 1.0);
57 
58  // "order of log truncation (0=none, 2=quadratic, 3=cubic)"
59  _log_truncation = command_line_value("log_truncation", 2);
60 
61  if (!_log_truncation)
62  libMesh::out << "WARNING: no truncation is being used for the logarithmic free energy term.\nWARNING: division by zero possible!\n";
63 
64 
65  // Dimension
66  _dim = command_line_value("dim", 1);
67 
68  libmesh_assert_msg((_dim <= 3) && (_dim > 0), "Invalid mesh dimension");
69 
70  // Build the mesh
71  // Yes, it's better to make a coarse mesh and then refine it. We'll get to it later.
72  _N = command_line_value("N", 8);
73  libmesh_assert_msg(_N > 0, "Invalid mesh size");
74 
75  switch (_dim)
76  {
77  case 1:
78  MeshTools::Generation::build_line(_mesh, _N, 0.0, 1.0, EDGE2);
79  break;
80  case 2:
81  MeshTools::Generation::build_square(_mesh, _N, _N, 0.0, 1.0, 0.0, 1.0, QUAD4);
82  break;
83  case 3:
84  MeshTools::Generation::build_cube(_mesh, _N, _N, _N, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, HEX8);
85  break;
86  default:
87  libmesh_assert_msg((_dim <= 3) && (_dim > 0), "Invalid mesh dimension");
88  break;
89  }
90 
91  // Determine the initial timestep size
92  _dt0 = command_line_value("dt", 1.0/(10*_kappa*_N*_N*_N*_N));
93  libmesh_assert_msg(_dt0>=0, "Negative initial timestep");
94 
95  _t0 = command_line_value("min_time", 0.0);
96  _t1 = command_line_value("max_time", _t0 + 50.0*_dt0);
97  libmesh_assert_msg(_t1 >= _t0, "Final time less than initial time");
98  _T = _t1 - _t0;
99 
100  _cnWeight = command_line_value("crank_nicholson_weight", 1.0);
101  libmesh_assert_msg(_cnWeight <= 1 && _cnWeight >= 0, "Crank-Nicholson weight must be between 0 and 1");
102 
103  // Initial state
104  _initialState = STRIP;
105  std::string initialState = command_line_value("initial_state", std::string("strip"));
106 
107  if (initialState == std::string("ball"))
108  _initialState = BALL;
109  else if (initialState == std::string("strip"))
110  _initialState = STRIP;
111  else if (initialState == std::string("rod"))
112  _initialState = ROD;
113  else
114  libmesh_error_msg("Unknown initial state: neither ball nor rod nor strip");
115 
116  std::vector<Real> icenter;
117  command_line_vector("initial_center", icenter);
118 
119  // Check that the point defining the center was in the right spatial dimension
120  if (icenter.size() > _dim)
121  libmesh_assert_msg(icenter.size() > _dim, "Invalid dimension for the initial state center of mass");
122 
123  // Pad
124  icenter.resize(3);
125  for (std::size_t i = icenter.size(); i < _dim; ++i)
126  icenter[i] = 0.5;
127 
128  for (unsigned int i = _dim; i < 3; ++i)
129  icenter[i] = 0.0;
130 
131  _initialCenter = Point(icenter[0], icenter[1], icenter[2]);
132  _initialWidth = command_line_value("initial_width", 0.125);
133 
134  // Output options
135 #ifdef LIBMESH_HAVE_EXODUS_API
136  if (on_command_line("output_base"))
137  _ofile_base = command_line_value("output_base", std::string("bih"));
138 
139  else
140  {
141  switch(_dim)
142  {
143  case 1:
144  _ofile_base = std::string("bih.1");
145  break;
146  case 2:
147  _ofile_base = std::string("bih.2");
148  break;
149  case 3:
150  _ofile_base = std::string("bih.3");
151  break;
152  default:
153  _ofile_base = std::string("bih");
154  break;
155  }
156  }
157  _ofile = _ofile_base + ".e";
158  _exio = std::make_unique<ExodusII_IO>(_mesh);
159  _o_dt = command_line_value("output_dt", 0.0);
160 #endif // #ifdef LIBMESH_HAVE_EXODUS_API
161 } // constructor
libMesh::EquationSystems::EquationSystems
EquationSystems(MeshBase &mesh)
Constructor.
Definition: equation_systems.C:52
Biharmonic::_ofile
std::string _ofile
Definition: biharmonic.h:105
Biharmonic::_exio
std::unique_ptr< ExodusII_IO > _exio
Definition: biharmonic.h:106
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98
Biharmonic::_cnWeight
Real _cnWeight
Definition: biharmonic.h:103
mesh
MeshBase & mesh
Definition: mesh_communication.C:1476
Biharmonic::_kappa
Real _kappa
Definition: biharmonic.h:93
Biharmonic::_theta_c
Real _theta_c
Definition: biharmonic.h:93
libMesh::MeshTools::Generation::build_square
void build_square(UnstructuredMesh &mesh, const unsigned int nx, const unsigned int ny, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
A specialized build_cube() for 2D meshes.
Definition: mesh_generation.C:1694
Biharmonic::_initialCenter
Point _initialCenter
Definition: biharmonic.h:100
Biharmonic::_tol
Real _tol
Definition: biharmonic.h:94
Biharmonic::_netforce
bool _netforce
Definition: biharmonic.h:95
Biharmonic::_cahn_hillard
bool _cahn_hillard
Definition: biharmonic.h:95
libMesh::command_line_value
T command_line_value(const std::string &, T)
Definition: libmesh.C:1024
Biharmonic::_energy
FreeEnergyEnum _energy
Definition: biharmonic.h:96
Biharmonic::_log_truncation
int _log_truncation
Definition: biharmonic.h:97
Biharmonic::_dim
unsigned int _dim
Definition: biharmonic.h:92
Biharmonic::_initialWidth
Real _initialWidth
Definition: biharmonic.h:101
libMesh::command_line_vector
void command_line_vector(const std::string &, std::vector< T > &)
Definition: libmesh.C:1097
libMesh::out
OStreamProxy out
Biharmonic::_growth
bool _growth
Definition: biharmonic.h:95
libMesh::MeshTools::Generation::build_line
void build_line(UnstructuredMesh &mesh, const unsigned int nx, const Real xmin=0., const Real xmax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
A specialized build_cube() for 1D meshes.
Definition: mesh_generation.C:1673
libMesh::on_command_line
bool on_command_line(std::string arg)
Definition: libmesh.C:987
Biharmonic::_o_dt
Real _o_dt
Definition: biharmonic.h:107
Biharmonic::_N
unsigned int _N
Definition: biharmonic.h:92
Biharmonic::_mesh
ReplicatedMesh & _mesh
Definition: biharmonic.h:111
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39
Biharmonic::_ofile_base
std::string _ofile_base
Definition: biharmonic.h:105
Biharmonic::_initialState
InitialStateEnum _initialState
Definition: biharmonic.h:99
libMesh::MeshTools::Generation::build_cube
void build_cube(UnstructuredMesh &mesh, const unsigned int nx=0, const unsigned int ny=0, const unsigned int nz=0, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const Real zmin=0., const Real zmax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
Builds a (elements) cube.
Definition: mesh_generation.C:313
Biharmonic::_theta
Real _theta
Definition: biharmonic.h:93
Biharmonic::_degenerate
bool _degenerate
Definition: biharmonic.h:95

◆ ~Biharmonic()

Biharmonic::~Biharmonic ( )
inline

Destructor.

Definition at line 72 of file biharmonic.h.

73  {
74  // delete _meshRefinement;
75  }

Member Function Documentation

◆ add_system() [1/2]

System & libMesh::EquationSystems::add_system ( std::string_view  system_type,
std::string_view  name 
)
virtualinherited

Add the system of type system_type named name to the systems array.

Definition at line 338 of file equation_systems.C.

References libMesh::EquationSystems::_systems, libMesh::EquationSystems::get_system(), and libMesh::Quality::name().

Referenced by assemble_and_solve(), build_system(), main(), libMesh::ErrorVector::plot_error(), libMesh::EquationSystems::read(), libMesh::StaticCondensationDofMap::reinit(), TimeSolverTestImplementation< NewmarkSolver >::run_test_with_exact_soln(), setup(), WriteVecAndScalar::setupTests(), SystemsTest::simpleSetup(), libMesh::VariationalMeshSmoother::smooth(), MultiEvaluablePredTest::test(), SystemsTest::test100KVariables(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), MeshFunctionTest::test_subdomain_id_sets(), EquationSystemsTest::testAddSystem(), SystemsTest::testAssemblyWithDgFemContext(), DofMapTest::testBadElemFECombo(), EquationSystemsTest::testBadVarNames(), SystemsTest::testBlockRestrictedVarNDofs(), SystemsTest::testBoundaryProjectCube(), DofMapTest::testConstraintLoopDetection(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), ConstraintOperatorTest::testCoreform(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), EquationSystemsTest::testDisableDefaultGhosting(), SystemsTest::testDofCouplingWithVarGroups(), MixedDimensionMeshTest::testDofOrdering(), MixedDimensionRefinedMeshTest::testDofOrdering(), MixedDimensionNonUniformRefinement::testDofOrdering(), MixedDimensionNonUniformRefinementTriangle::testDofOrdering(), MixedDimensionNonUniformRefinement3D::testDofOrdering(), DofMapTest::testDofOwner(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), EquationSystemsTest::testInit(), MeshAssignTest::testMeshMoveAssign(), PeriodicBCTest::testPeriodicBC(), EquationSystemsTest::testPostInitAddElem(), EquationSystemsTest::testPostInitAddRealSystem(), EquationSystemsTest::testPostInitAddSystem(), SystemsTest::testProjectCube(), SystemsTest::testProjectCubeWithMeshFunction(), MeshInputTest::testProjectionRegression(), SystemsTest::testProjectLine(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), SystemsTest::testProjectSquare(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testReinitWithNodeElem(), EquationSystemsTest::testRepartitionThenReinit(), EquationSystemsTest::testSelectivePRefine(), SystemsTest::testSetSystemParameterOverEquationSystem(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testWriteExodus(), and WriteVecAndScalar::testWriteNemesis().

340 {
341  // If the user already built a system with this name, we'll
342  // trust them and we'll use it. That way they can pre-add
343  // non-standard derived system classes, and if their restart file
344  // has some non-standard sys_type we won't throw an error.
345  if (_systems.count(name))
346  {
347  return this->get_system(name);
348  }
349  // Build a basic System
350  else if (sys_type == "Basic")
351  this->add_system<System> (name);
352 
353  // Build a Newmark system
354  else if (sys_type == "Newmark")
355  this->add_system<NewmarkSystem> (name);
356 
357  // Build an Explicit system
358  else if ((sys_type == "Explicit"))
359  this->add_system<ExplicitSystem> (name);
360 
361  // Build an Implicit system
362  else if ((sys_type == "Implicit") ||
363  (sys_type == "Steady" ))
364  this->add_system<ImplicitSystem> (name);
365 
366  // build a transient implicit linear system
367  else if ((sys_type == "Transient") ||
368  (sys_type == "TransientImplicit") ||
369  (sys_type == "TransientLinearImplicit"))
370  this->add_system<TransientLinearImplicitSystem> (name);
371 
372  // build a transient implicit nonlinear system
373  else if (sys_type == "TransientNonlinearImplicit")
374  this->add_system<TransientNonlinearImplicitSystem> (name);
375 
376  // build a transient explicit system
377  else if (sys_type == "TransientExplicit")
378  this->add_system<TransientExplicitSystem> (name);
379 
380  // build a linear implicit system
381  else if (sys_type == "LinearImplicit")
382  this->add_system<LinearImplicitSystem> (name);
383 
384  // build a nonlinear implicit system
385  else if (sys_type == "NonlinearImplicit")
386  this->add_system<NonlinearImplicitSystem> (name);
387 
388  // build a Reduced Basis Construction system
389  else if (sys_type == "RBConstruction")
390  this->add_system<RBConstruction> (name);
391 
392  // build a transient Reduced Basis Construction system
393  else if (sys_type == "TransientRBConstruction")
394  this->add_system<TransientRBConstruction> (name);
395 
396 #ifdef LIBMESH_HAVE_SLEPC
397  // build an eigen system
398  else if (sys_type == "Eigen")
399  this->add_system<EigenSystem> (name);
400  else if (sys_type == "TransientEigenSystem")
401  this->add_system<TransientEigenSystem> (name);
402 #endif
403 
404 #if defined(LIBMESH_USE_COMPLEX_NUMBERS)
405  // build a frequency system
406  else if (sys_type == "Frequency")
407  this->add_system<FrequencySystem> (name);
408 #endif
409 
410  else
411  libmesh_error_msg("ERROR: Unknown system type: " << sys_type);
412 
413  // Return a reference to the new system
414  //return (*this)(name);
415  return this->get_system(name);
416 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ add_system() [2/2]

template<typename T_sys >
T_sys & libMesh::EquationSystems::add_system ( std::string_view  name)
inlineinherited

Add the system named name to the systems array.

Definition at line 671 of file equation_systems.h.

References libMesh::EquationSystems::_add_system_to_nodes_and_elems(), libMesh::EquationSystems::_enable_default_ghosting, libMesh::EquationSystems::_remove_default_ghosting(), libMesh::EquationSystems::_systems, libMesh::EquationSystems::n_systems(), and libMesh::Quality::name().

672 {
673  if (!_systems.count(name))
674  {
675  const unsigned int sys_num = this->n_systems();
676 
677  auto result = _systems.emplace
678  (name, std::make_unique<T_sys>(*this, std::string(name),
679  sys_num));
680 
681  if (!_enable_default_ghosting)
682  this->_remove_default_ghosting(sys_num);
683 
684  // Tell all the \p DofObject entities to add a system.
685  this->_add_system_to_nodes_and_elems();
686 
687  // Return reference to newly added item
688  auto it = result.first;
689  auto & sys_ptr = it->second;
690  return cast_ref<T_sys &>(*sys_ptr);
691  }
692  else
693  {
694  // We now allow redundant add_system calls, to make it
695  // easier to load data from files for user-derived system
696  // subclasses
697  return this->get_system<T_sys>(name);
698  }
699 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::_enable_default_ghosting
bool _enable_default_ghosting
Flag for whether to enable default ghosting on newly added Systems.
Definition: equation_systems.h:623
libMesh::EquationSystems::_remove_default_ghosting
void _remove_default_ghosting(unsigned int sys_num)
This just calls DofMap::remove_default_ghosting() but using a shim lets us forward-declare DofMap...
Definition: equation_systems.C:1754
libMesh::EquationSystems::_add_system_to_nodes_and_elems
void _add_system_to_nodes_and_elems()
This function is used in the implementation of add_system, it loops over the nodes and elements of th...
Definition: equation_systems.C:1743
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ adjoint_solve()

void libMesh::EquationSystems::adjoint_solve ( const QoISet &  qoi_indices = QoISet())
virtualinherited

Call adjoint_solve on all the individual equation systems.

By default this function solves each system's adjoint once, in the reverse order from that in which they were added. For more sophisticated decoupled problems the user may with to override this behavior in a derived class.

Definition at line 440 of file equation_systems.C.

References libMesh::EquationSystems::get_system(), libMesh::libmesh_assert(), and libMesh::EquationSystems::n_systems().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error().

441 {
442  libmesh_assert (this->n_systems());
443 
444  for (unsigned int i=this->n_systems(); i != 0; --i)
445  this->get_system(i-1).adjoint_solve(qoi_indices);
446 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::libmesh_assert
libmesh_assert(ctx)

◆ allgather()

void libMesh::EquationSystems::allgather ( )
inherited

Serializes a distributed mesh and its associated degree of freedom numbering for all systems.

Definition at line 265 of file equation_systems.C.

References libMesh::EquationSystems::_mesh, libMesh::MeshBase::allgather(), libMesh::DofMap::distribute_dofs(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_system(), libMesh::MeshBase::is_serial(), libMesh::make_range(), libMesh::EquationSystems::n_systems(), and libMesh::System::reinit_constraints().

266 {
267  // A serial mesh means nothing needs to be done
268  if (_mesh.is_serial())
269  return;
270 
271  const unsigned int n_sys = this->n_systems();
272 
273  libmesh_assert_not_equal_to (n_sys, 0);
274 
275  // Gather the mesh
276  _mesh.allgather();
277 
278  // Tell all the \p DofObject entities how many systems
279  // there are.
280  for (auto & node : _mesh.node_ptr_range())
281  node->set_n_systems(n_sys);
282 
283  for (auto & elem : _mesh.element_ptr_range())
284  elem->set_n_systems(n_sys);
285 
286  // And distribute each system's dofs
287  for (auto i : make_range(this->n_systems()))
288  {
289  System & sys = this->get_system(i);
290  DofMap & dof_map = sys.get_dof_map();
291  dof_map.distribute_dofs(_mesh);
292 
293  // The user probably won't need constraint equations or the
294  // send_list after an allgather, but let's keep it in consistent
295  // shape just in case.
296  sys.reinit_constraints();
297 
298  // Even if there weren't any constraint changes,
299  // reinit_constraints() did prepare_send_list() for us.
300  }
301 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::MeshBase::allgather
virtual void allgather()
Gathers all elements and nodes of the mesh onto every processor.
Definition: mesh_base.h:240
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::MeshBase::is_serial
virtual bool is_serial() const
Definition: mesh_base.h:211
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ build_discontinuous_solution_vector()

void libMesh::EquationSystems::build_discontinuous_solution_vector ( std::vector< Number > &  soln,
const std::set< std::string > *  system_names = nullptr,
const std::vector< std::string > *  var_names = nullptr,
bool  vertices_only = false,
bool  add_sides = false 
) const
inherited

Fill the input vector soln with solution values.

The entries will be in variable-major format (corresponding to the names from build_variable_names()).

If systems_names!=nullptr, only include data from the specified systems.

If vertices_only == true, then for higher-order elements only the solution at the vertices is computed. This can be useful when plotting discontinuous solutions on higher-order elements and only a lower-order representation is required.

If add_sides == true, append data for plotting on "side elements" too.

Definition at line 1262 of file equation_systems.C.

References libMesh::Variable::active_on_subdomain(), libMesh::DISCONTINUOUS, libMesh::FEInterface::get_continuity(), libMesh::H_CURL, libMesh::H_DIV, libMesh::index_range(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::FEInterface::n_vec_dim(), libMesh::Elem::neighbor_ptr(), libMesh::FEInterface::nodal_soln(), libMesh::Elem::node_ptr(), libMesh::Elem::nodes_on_side(), libMesh::FEInterface::side_nodal_soln(), libMesh::Elem::subdomain_id(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems(), libMesh::ExodusII_IO::write_discontinuous_exodusII(), libMesh::GMVIO::write_discontinuous_gmv(), and libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data().

1267 {
1268  LOG_SCOPE("build_discontinuous_solution_vector()", "EquationSystems");
1269 
1270  libmesh_assert (this->n_systems());
1271 
1272  // Get the number of variables (nv) by counting the number of variables
1273  // in each system listed in system_names
1274  unsigned int nv = 0;
1275 
1276  for (const auto & [sys_name, sys_ptr] : _systems)
1277  {
1278  // Check current system is listed in system_names, and skip pos if not
1279  bool use_current_system = (system_names == nullptr);
1280  if (!use_current_system)
1281  use_current_system = system_names->count(sys_name);
1282  if (!use_current_system || sys_ptr->hide_output())
1283  continue;
1284 
1285  // Loop over all variables in this System and check whether we
1286  // are supposed to use each one.
1287  for (auto var_id : make_range(sys_ptr->n_vars()))
1288  {
1289  bool use_current_var = (var_names == nullptr);
1290  if (!use_current_var)
1291  use_current_var = std::count(var_names->begin(),
1292  var_names->end(),
1293  sys_ptr->variable_name(var_id));
1294 
1295  // Only increment the total number of vars if we are
1296  // supposed to use this one.
1297  if (use_current_var)
1298  nv++;
1299  }
1300  }
1301 
1302  // get the total "weight" - the number of nodal values to write for
1303  // each variable.
1304  unsigned int tw=0;
1305  for (const auto & elem : _mesh.active_element_ptr_range())
1306  {
1307  tw += vertices_only ? elem->n_vertices() : elem->n_nodes();
1308 
1309  if (add_sides)
1310  {
1311  for (auto s : elem->side_index_range())
1312  {
1313  if (redundant_added_side(*elem,s))
1314  continue;
1315 
1316  const std::vector<unsigned int> side_nodes =
1317  elem->nodes_on_side(s);
1318 
1319  if (!vertices_only)
1320  tw += side_nodes.size();
1321  else
1322  for (auto n : index_range(side_nodes))
1323  if (elem->is_vertex(side_nodes[n]))
1324  ++tw;
1325  }
1326  }
1327  }
1328 
1329  // Only if we are on processor zero, allocate the storage
1330  // to hold (number_of_nodes)*(number_of_variables) entries.
1331  if (_mesh.processor_id() == 0)
1332  soln.resize(tw*nv);
1333 
1334  std::vector<Number> sys_soln;
1335 
1336  // Keep track of the variable "offset". This is used for indexing
1337  // into the global solution vector.
1338  unsigned int var_offset = 0;
1339 
1340  // For each system in this EquationSystems object,
1341  // update the global solution and if we are on processor 0,
1342  // loop over the elements and build the nodal solution
1343  // from the element solution. Then insert this nodal solution
1344  // into the vector passed to build_solution_vector.
1345  for (const auto & [sys_name, system] : _systems)
1346  {
1347  // Check current system is listed in system_names, and skip pos if not
1348  bool use_current_system = (system_names == nullptr);
1349  if (!use_current_system)
1350  use_current_system = system_names->count(sys_name);
1351  if (!use_current_system || system->hide_output())
1352  continue;
1353 
1354  const unsigned int nv_sys = system->n_vars();
1355  const auto & dof_map = system->get_dof_map();
1356 
1357  system->update_global_solution (sys_soln, 0);
1358 
1359  // Keep track of the number of vars actually written.
1360  unsigned int n_vars_written_current_system = 0;
1361 
1362  if (_mesh.processor_id() == 0)
1363  {
1364  std::vector<Number> soln_coeffs; // The finite element solution coeffs
1365  std::vector<Number> nodal_soln; // The FE solution interpolated to the nodes
1366  std::vector<dof_id_type> dof_indices; // The DOF indices for the finite element
1367 
1368  // For each variable, determine if we are supposed to
1369  // write it, then loop over the active elements, compute
1370  // the nodal_soln and store it to the "soln" vector. We
1371  // store zeros for subdomain-restricted variables on
1372  // elements where they are not active.
1373  for (unsigned int var=0; var<nv_sys; var++)
1374  {
1375  bool use_current_var = (var_names == nullptr);
1376  if (!use_current_var)
1377  use_current_var = std::count(var_names->begin(),
1378  var_names->end(),
1379  system->variable_name(var));
1380 
1381  // If we aren't supposed to write this var, go to the
1382  // next loop iteration.
1383  if (!use_current_var)
1384  continue;
1385 
1386  const FEType & fe_type = system->variable_type(var);
1387  const Variable & var_description = system->variable(var);
1388  const auto vg = dof_map.var_group_from_var_number(var);
1389  const bool add_p_level = dof_map.should_p_refine(vg);
1390 
1391  unsigned int nn=0;
1392 
1393  for (auto & elem : _mesh.active_element_ptr_range())
1394  {
1395  if (var_description.active_on_subdomain(elem->subdomain_id()))
1396  {
1397  system->get_dof_map().dof_indices (elem, dof_indices, var);
1398 
1399  soln_coeffs.resize(dof_indices.size());
1400 
1401  for (auto i : index_range(dof_indices))
1402  soln_coeffs[i] = sys_soln[dof_indices[i]];
1403 
1404  // Compute the FE solution at all the nodes, but
1405  // only use the first n_vertices() entries if
1406  // vertices_only == true.
1407  FEInterface::nodal_soln (elem->dim(),
1408  fe_type,
1409  elem,
1410  soln_coeffs,
1411  nodal_soln,
1412  add_p_level,
1413  FEInterface::n_vec_dim(_mesh, fe_type));
1414 
1415  // infinite elements should be skipped...
1416  if (!elem->infinite())
1417  {
1418  libmesh_assert_equal_to (nodal_soln.size(), elem->n_nodes());
1419 
1420  const unsigned int n_vals =
1421  vertices_only ? elem->n_vertices() : elem->n_nodes();
1422 
1423  for (unsigned int n=0; n<n_vals; n++)
1424  {
1425  // Compute index into global solution vector.
1426  std::size_t index =
1427  nv * (nn++) + (n_vars_written_current_system + var_offset);
1428 
1429  soln[index] += nodal_soln[n];
1430  }
1431  }
1432  }
1433  else
1434  nn += vertices_only ? elem->n_vertices() : elem->n_nodes();
1435  } // end loop over active elements writing interiors
1436 
1437  // Loop writing "fake" sides, if requested
1438  if (add_sides)
1439  {
1440  // We don't build discontinuous solution vectors in
1441  // parallel yet, but we'll do ordering of fake side
1442  // values as if we did, for consistency with the
1443  // parallel continuous ordering and for future
1444  // compatibility.
1445  std::vector<std::vector<const Elem *>>
1446  elems_by_pid(_mesh.n_processors());
1447 
1448  for (const auto & elem : _mesh.active_element_ptr_range())
1449  elems_by_pid[elem->processor_id()].push_back(elem);
1450 
1451  for (auto p : index_range(elems_by_pid))
1452  for (const Elem * elem : elems_by_pid[p])
1453  {
1454  if (var_description.active_on_subdomain(elem->subdomain_id()))
1455  {
1456  system->get_dof_map().dof_indices (elem, dof_indices, var);
1457 
1458  soln_coeffs.resize(dof_indices.size());
1459 
1460  for (auto i : index_range(dof_indices))
1461  soln_coeffs[i] = sys_soln[dof_indices[i]];
1462 
1463  for (auto s : elem->side_index_range())
1464  {
1465  if (redundant_added_side(*elem,s))
1466  continue;
1467 
1468  const std::vector<unsigned int> side_nodes =
1469  elem->nodes_on_side(s);
1470 
1471  // Compute the FE solution at all the
1472  // side nodes, but only use those for
1473  // which is_vertex() == true if
1474  // vertices_only == true.
1475  FEInterface::side_nodal_soln
1476  (fe_type, elem, s, soln_coeffs,
1477  nodal_soln, add_p_level,
1478  FEInterface::n_vec_dim(_mesh, fe_type));
1479 
1480  libmesh_assert_equal_to
1481  (nodal_soln.size(),
1482  side_nodes.size());
1483 
1484  // If we don't have a continuous FE
1485  // then we want to average between
1486  // sides, at least in the equal-level
1487  // case where it's easy. This is
1488  // analogous to our repeat_count
1489  // behavior elsewhere.
1490  const FEContinuity cont =
1491  FEInterface::get_continuity(fe_type);
1492  const Elem * const neigh = elem->neighbor_ptr(s);
1493 
1494  if ((cont == DISCONTINUOUS || cont == H_CURL || cont == H_DIV) &&
1495  neigh &&
1496  neigh->level() == elem->level() &&
1497  var_description.active_on_subdomain(neigh->subdomain_id()))
1498  {
1499  std::vector<dof_id_type> neigh_indices;
1500  system->get_dof_map().dof_indices (neigh, neigh_indices, var);
1501  std::vector<Number> neigh_coeffs(neigh_indices.size());
1502 
1503  for (auto i : index_range(neigh_indices))
1504  neigh_coeffs[i] = sys_soln[neigh_indices[i]];
1505 
1506  const unsigned int s_neigh =
1507  neigh->which_neighbor_am_i(elem);
1508  std::vector<Number> neigh_soln;
1509  FEInterface::side_nodal_soln
1510  (fe_type, neigh, s_neigh,
1511  neigh_coeffs, neigh_soln, add_p_level,
1512  FEInterface::n_vec_dim(_mesh, fe_type));
1513 
1514  const std::vector<unsigned int> neigh_nodes =
1515  neigh->nodes_on_side(s_neigh);
1516  for (auto n : index_range(side_nodes))
1517  for (auto neigh_n : index_range(neigh_nodes))
1518  if (neigh->node_ptr(neigh_nodes[neigh_n])
1519  == elem->node_ptr(side_nodes[n]))
1520  {
1521  nodal_soln[n] += neigh_soln[neigh_n];
1522  nodal_soln[n] /= 2;
1523  }
1524  }
1525 
1526  for (auto n : index_range(side_nodes))
1527  {
1528  if (vertices_only &&
1529  !elem->is_vertex(n))
1530  continue;
1531 
1532  // Compute index into global solution vector.
1533  std::size_t index =
1534  nv * (nn++) + (n_vars_written_current_system + var_offset);
1535 
1536  soln[index] += nodal_soln[n];
1537  }
1538  }
1539  }
1540  else
1541  {
1542  nn += vertices_only ? elem->n_vertices() : elem->n_nodes();
1543 
1544  for (auto s : elem->side_index_range())
1545  {
1546  if (redundant_added_side(*elem,s))
1547  continue;
1548 
1549  const std::vector<unsigned int> side_nodes =
1550  elem->nodes_on_side(s);
1551 
1552  for (auto n : index_range(side_nodes))
1553  {
1554  if (vertices_only &&
1555  !elem->is_vertex(n))
1556  continue;
1557  nn++;
1558  }
1559  }
1560  }
1561  } // end loop over active elements, writing "fake" sides
1562  }
1563  // If we made it here, we actually wrote a variable, so increment
1564  // the number of variables actually written for the current system.
1565  n_vars_written_current_system++;
1566 
1567  } // end loop over vars
1568  } // end if proc 0
1569 
1570  // Update offset for next loop iteration.
1571  var_offset += n_vars_written_current_system;
1572  } // end loop over systems
1573 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::FEInterface::side_nodal_soln
static void side_nodal_soln(const FEType &fe_t, const Elem *elem, const unsigned int side, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln on one side from the (full) element soln.
Definition: fe_interface.C:650
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::ParallelObject::n_processors
processor_id_type n_processors() const
Definition: parallel_object.h:103
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::FEInterface::n_vec_dim
static unsigned int n_vec_dim(const MeshBase &mesh, const FEType &fe_type)
Definition: fe_interface.C:2677
libMesh::FEInterface::get_continuity
static FEContinuity get_continuity(const FEType &fe_type)
Returns the input FEType&#39;s FEContinuity based on the underlying FEFamily and potentially the Order...
Definition: fe_interface.C:2725
libMesh::FEContinuity
FEContinuity
defines an enum for finite element types to libmesh_assert a certain level (or type? Hcurl?) of continuity.
Definition: enum_fe_family.h:84
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114
libMesh::FEInterface::nodal_soln
static void nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln from the element soln.
Definition: fe_interface.C:625
libMesh::index_range
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611
libMesh::EquationSystems::redundant_added_side
static bool redundant_added_side(const Elem &elem, unsigned int side)
Definition: equation_systems.C:1577

◆ build_elemental_solution_vector()

void libMesh::EquationSystems::build_elemental_solution_vector ( std::vector< Number > &  soln,
std::vector< std::string > &  names 
) const
inherited

Retrieve the solution data for CONSTANT MONOMIALs and/or components of CONSTANT MONOMIAL_VECs.

If 'names' is populated, only the variables corresponding to those names will be retrieved. This can be used to filter which variables are retrieved.

This is the more appropriately-named replacement for the get_solution() function defined above.

Definition at line 1027 of file equation_systems.C.

References libMesh::EquationSystems::build_parallel_elemental_solution_vector().

Referenced by libMesh::EquationSystems::get_solution(), and libMesh::ExodusII_IO::write_element_data().

1029 {
1030  // Call the parallel version of this function
1031  std::unique_ptr<NumericVector<Number>> parallel_soln =
1032  this->build_parallel_elemental_solution_vector(names);
1033 
1034  // Localize into 'soln', provided that parallel_soln is not empty.
1035  // Note: parallel_soln will be empty in the event that none of the
1036  // input names were CONSTANT, MONOMIAL nor components of CONSTANT,
1037  // MONOMIAL_VEC variables, or there were simply none of these in
1038  // the EquationSystems object.
1039  soln.clear();
1040  if (parallel_soln)
1041  parallel_soln->localize_to_one(soln);
1042 }
libMesh::EquationSystems::build_parallel_elemental_solution_vector
std::unique_ptr< NumericVector< Number > > build_parallel_elemental_solution_vector(std::vector< std::string > &names) const
Builds a parallel vector of CONSTANT MONOMIAL and/or components of CONSTANT MONOMIAL_VEC solution val...
Definition: equation_systems.C:1151

◆ build_parallel_elemental_solution_vector()

std::unique_ptr< NumericVector< Number > > libMesh::EquationSystems::build_parallel_elemental_solution_vector ( std::vector< std::string > &  names) const
inherited

Builds a parallel vector of CONSTANT MONOMIAL and/or components of CONSTANT MONOMIAL_VEC solution values corresponding to the entries in the input 'names' vector.

This vector is approximately uniformly distributed across all of the available processors.

The related function build_elemental_solution_vector() is implemented by calling this function and then calling localize_to_one() on the resulting vector.

Returns a nullptr if no CONSTANT, MONOMIAL/MONOMIAL_VEC variables exist in the 'names' vector (if it is empty, then it will return all variables in the system of this type if any) or a std::unique_ptr to a var-major numeric vector of total length n_elem * n_vars, where n_vars includes all components of vectors, ordered according to: [u0, u1, ... uN, v0, v1, ... vN, w0, w1, ... wN] for constant monomial variables (u, v, w) on a mesh with N elements.

Definition at line 1151 of file equation_systems.C.

References libMesh::ParallelObject::_communicator, libMesh::EquationSystems::_mesh, libMesh::Variable::active_on_subdomain(), libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::ParallelObject::comm(), libMesh::CONSTANT, libMesh::System::current_local_solution, libMesh::DofMap::dof_indices(), libMesh::EquationSystems::find_variable_numbers(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_system(), libMesh::index_range(), libMesh::NumericVector< T >::init(), libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::MeshBase::n_elem(), libMesh::ParallelObject::n_processors(), libMesh::PARALLEL, libMesh::ParallelObject::processor_id(), libMesh::NumericVector< T >::set(), libMesh::System::solution, libMesh::MeshBase::spatial_dimension(), libMesh::System::update(), libMesh::System::variable(), and libMesh::System::variable_type().

Referenced by libMesh::EquationSystems::build_elemental_solution_vector().

1152 {
1153  // Filter any names that aren't elemental variables and get the system indices for those that are.
1154  // Note that it's probably fine if the names vector is empty since we'll still at least filter
1155  // out all non-monomials. If there are no monomials, then nothing is output here.
1156  std::vector<FEType> type = {FEType(CONSTANT, MONOMIAL), FEType(CONSTANT, MONOMIAL_VEC)};
1157  std::vector<std::pair<unsigned int, unsigned int>> var_nums =
1158  this->find_variable_numbers(names, /*type=*/nullptr, &type);
1159 
1160  const std::size_t nv = names.size(); /*total number of vars including vector components*/
1161  const dof_id_type ne = _mesh.n_elem();
1162  libmesh_assert_equal_to (ne, _mesh.max_elem_id());
1163 
1164  // If there are no variables to write out don't do anything...
1165  if (!nv)
1166  return std::unique_ptr<NumericVector<Number>>(nullptr);
1167 
1168  // We can handle the case where there are nullptrs in the Elem vector
1169  // by just having extra zeros in the solution vector.
1170  numeric_index_type parallel_soln_global_size = ne*nv;
1171 
1172  numeric_index_type div = parallel_soln_global_size / this->n_processors();
1173  numeric_index_type mod = parallel_soln_global_size % this->n_processors();
1174 
1175  // Initialize all processors to the average size.
1176  numeric_index_type parallel_soln_local_size = div;
1177 
1178  // The first "mod" processors get an extra entry.
1179  if (this->processor_id() < mod)
1180  parallel_soln_local_size = div+1;
1181 
1182  // Create a NumericVector to hold the parallel solution
1183  std::unique_ptr<NumericVector<Number>> parallel_soln_ptr = NumericVector<Number>::build(_communicator);
1184  NumericVector<Number> & parallel_soln = *parallel_soln_ptr;
1185  parallel_soln.init(parallel_soln_global_size,
1186  parallel_soln_local_size,
1187  /*fast=*/false,
1188  /*ParallelType=*/PARALLEL);
1189 
1190  unsigned int sys_ctr = 0;
1191  unsigned int var_ctr = 0;
1192  for (auto i : index_range(var_nums))
1193  {
1194  std::pair<unsigned int, unsigned int> var_num = var_nums[i];
1195  const System & system = this->get_system(var_num.first);
1196 
1197  // Update the current_local_solution if necessary
1198  if (sys_ctr != var_num.first)
1199  {
1200  System & non_const_sys = const_cast<System &>(system);
1201  // We used to simply call non_const_sys.solution->close()
1202  // here, but that is not allowed when the solution vector is
1203  // locked read-only, for example when printing the solution
1204  // during during the middle of a solve... So try to be a bit
1205  // more careful about calling close() unnecessarily.
1206  libmesh_assert(this->comm().verify(non_const_sys.solution->closed()));
1207  if (!non_const_sys.solution->closed())
1208  non_const_sys.solution->close();
1209  non_const_sys.update();
1210  sys_ctr = var_num.first;
1211  }
1212 
1213  NumericVector<Number> & sys_soln(*system.current_local_solution);
1214 
1215  // The DOF indices for the finite element
1216  std::vector<dof_id_type> dof_indices;
1217 
1218  const unsigned int var = var_num.second;
1219 
1220  const Variable & variable = system.variable(var);
1221  const DofMap & dof_map = system.get_dof_map();
1222 
1223  // We need to check if the constant monomial is a scalar or a vector and set the number of
1224  // components as the mesh spatial dimension for the latter as per es.find_variable_numbers().
1225  // Even for the case where a variable is not active on any subdomain belonging to the
1226  // processor, we still need to know this number to update 'var_ctr'.
1227  const unsigned int n_comps =
1228  (system.variable_type(var) == type[1]) ? _mesh.spatial_dimension() : 1;
1229 
1230  // Loop over all elements in the mesh and index all components of the variable if it's active
1231  for (const auto & elem : _mesh.active_local_element_ptr_range())
1232  if (variable.active_on_subdomain(elem->subdomain_id()))
1233  {
1234  dof_map.dof_indices(elem, dof_indices, var);
1235 
1236  // The number of DOF components needs to be equal to the expected number so that we know
1237  // where to store data to correctly correspond to variable names.
1238  libmesh_assert_equal_to(dof_indices.size(), n_comps);
1239 
1240  for (unsigned int comp = 0; comp < n_comps; comp++)
1241  parallel_soln.set(ne * (var_ctr + comp) + elem->id(), sys_soln(dof_indices[comp]));
1242  }
1243 
1244  var_ctr += n_comps;
1245  } // end loop over var_nums
1246 
1247  // NOTE: number of output names might not be equal to the number passed to this function. Any that
1248  // aren't CONSTANT MONOMIALS or components of CONSTANT MONOMIAL_VECS have been filtered out (see
1249  // EquationSystems::find_variable_numbers).
1250  //
1251  // But, if everything is accounted for properly, then names.size() == var_ctr
1252  libmesh_assert_equal_to(names.size(), var_ctr);
1253 
1254  parallel_soln.close();
1255  return parallel_soln_ptr;
1256 }
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition: parallel_object.h:97
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:120
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::ParallelObject::n_processors
processor_id_type n_processors() const
Definition: parallel_object.h:103
libMesh::numeric_index_type
dof_id_type numeric_index_type
Definition: id_types.h:99
libMesh::MeshBase::max_elem_id
virtual dof_id_type max_elem_id() const =0
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::MeshBase::spatial_dimension
unsigned int spatial_dimension() const
Definition: mesh_base.C:543
libMesh::NumericVector::build
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
Builds a NumericVector on the processors in communicator comm using the linear solver package specifi...
Definition: numeric_vector.C:61
libMesh::EquationSystems::find_variable_numbers
std::vector< std::pair< unsigned int, unsigned int > > find_variable_numbers(std::vector< std::string > &names, const FEType *type=nullptr, const std::vector< FEType > *types=nullptr) const
Finds system and variable numbers for any variables of &#39;type&#39; or of &#39;types&#39; corresponding to the entr...
Definition: equation_systems.C:1046
libMesh::MeshBase::n_elem
virtual dof_id_type n_elem() const =0
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114
libMesh::NumericVector< Number >
template class LIBMESH_EXPORT NumericVector< Number >
Definition: numeric_vector.C:704
libMesh::index_range
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
libMesh::dof_id_type
uint8_t dof_id_type
Definition: id_types.h:67

◆ build_parallel_solution_vector()

std::unique_ptr< NumericVector< Number > > libMesh::EquationSystems::build_parallel_solution_vector ( const std::set< std::string > *  system_names = nullptr,
bool  add_sides = false 
) const
inherited

A version of build_solution_vector which is appropriate for "parallel" output formats like Nemesis.

Returns
A std::unique_ptr to a node-major NumericVector of total length n_nodes*n_vars that various I/O classes can then use to get the local values they need to write on each processor.

Definition at line 581 of file equation_systems.C.

References libMesh::ParallelObject::_communicator, libMesh::EquationSystems::_mesh, libMesh::EquationSystems::_systems, libMesh::Variable::active_on_subdomain(), libMesh::NumericVector< T >::add(), TIMPI::Communicator::allgather(), libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, dim, distance(), libMesh::DofMap::dof_indices(), libMesh::FEInterface::field_type(), libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::get(), libMesh::System::get_dof_map(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::NumericVector< T >::init(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::MeshBase::max_node_id(), libMesh::DofObject::n_dofs(), libMesh::System::n_vars(), libMesh::FEInterface::n_vec_dim(), libMesh::FEInterface::nodal_soln(), libMesh::System::number(), libMesh::PARALLEL, libMesh::ParallelObject::processor_id(), TIMPI::Communicator::rank(), libMesh::EquationSystems::redundant_added_side(), libMesh::NumericVector< T >::set(), libMesh::DofMap::should_p_refine(), libMesh::FEInterface::side_nodal_soln(), TIMPI::Communicator::size(), libMesh::System::solution, libMesh::MeshBase::spatial_dimension(), TIMPI::Communicator::sum(), libMesh::TOLERANCE, libMesh::TYPE_VECTOR, libMesh::System::update(), libMesh::DofMap::var_group_from_var_number(), libMesh::System::variable(), and libMesh::System::variable_type().

Referenced by libMesh::EquationSystems::build_solution_vector(), and libMesh::MeshOutput< MeshBase >::write_nodal_data().

583 {
584  LOG_SCOPE("build_parallel_solution_vector()", "EquationSystems");
585 
586  // This function must be run on all processors at once
587  parallel_object_only();
588 
589  const unsigned int dim = _mesh.spatial_dimension();
590  const dof_id_type max_nn = _mesh.max_node_id();
591 
592  // allocate vector storage to hold
593  // (max_node_id)*(number_of_variables) entries.
594  //
595  // If node renumbering is disabled and adaptive coarsening has
596  // created gaps between node numbers, then this vector will be
597  // sparse.
598  //
599  // We have to differentiate between between scalar and vector
600  // variables. We intercept vector variables and treat each
601  // component as a scalar variable (consistently with build_solution_names).
602 
603  unsigned int nv = 0;
604 
605  //Could this be replaced by a/some convenience methods?[PB]
606  {
607  unsigned int n_scalar_vars = 0;
608  unsigned int n_vector_vars = 0;
609  for (const auto & [sys_name, sys_ptr] : _systems)
610  {
611  // Check current system is listed in system_names, and skip pos if not
612  bool use_current_system = (system_names == nullptr);
613  if (!use_current_system)
614  use_current_system = system_names->count(sys_name);
615  if (!use_current_system || sys_ptr->hide_output())
616  continue;
617 
618  for (auto vn : make_range(sys_ptr->n_vars()))
619  {
620  if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
621  n_vector_vars++;
622  else
623  n_scalar_vars++;
624  }
625  }
626  // Here, we're assuming the number of vector components is the same
627  // as the mesh spatial dimension.
628  nv = n_scalar_vars + dim*n_vector_vars;
629  }
630 
631  // Get the number of nodes to store locally.
632  dof_id_type n_local_nodes = cast_int<dof_id_type>
633  (std::distance(_mesh.local_nodes_begin(),
634  _mesh.local_nodes_end()));
635 
636  // If node renumbering has been disabled, nodes may not be numbered
637  // contiguously, and the number of nodes might not match the
638  // max_node_id. In this case we just do our best.
639  dof_id_type n_total_nodes = n_local_nodes;
640  _mesh.comm().sum(n_total_nodes);
641 
642  const processor_id_type n_proc = _mesh.comm().size();
643  const processor_id_type my_pid = _mesh.comm().rank();
644  const dof_id_type n_gaps = max_nn - n_total_nodes;
645  const dof_id_type gaps_per_processor = n_gaps / n_proc;
646  const dof_id_type remainder_gaps = n_gaps % n_proc;
647 
648  n_local_nodes = n_local_nodes + // Actual nodes
649  gaps_per_processor + // Our even share of gaps
650  (my_pid < remainder_gaps); // Leftovers
651 
652  // If we've been asked to build added sides' data, we need space to
653  // add it. Keep track of how much space.
654  dof_id_type local_added_side_nodes = 0,
655  added_side_nodes = 0;
656 
657  // others_added_side_nodes[p]: local_added_side_nodes on rank p
658  std::vector<dof_id_type> others_added_side_nodes;
659 
660  // A map of (element_id, side, side_node) pairs to the corresponding
661  // added side node index.
662  std::map<std::tuple<dof_id_type, unsigned short, unsigned short>,
663  dof_id_type> discontinuous_node_indices;
664 
665  // If we don't have any added side nodes, we'll have no offsets from
666  // them, and we won't care about which offsets apply to which node
667  // ids either.
668 
669  // Number of true nodes on processors [0,p]
670  std::vector<dof_id_type> true_node_offsets;
671  // Number of added (fake) nodes on processors [0,p)
672  std::vector<dof_id_type> added_node_offsets;
673 
674  auto node_id_to_vec_id =
675  [&true_node_offsets, &added_node_offsets]
676  (const dof_id_type node_id)
677  {
678  if (true_node_offsets.empty())
679  return node_id; // O(1) in the common !add_sides case
680 
681  // Find the processor id that has node_id in the parallel vec
682  const auto lb = std::upper_bound(true_node_offsets.begin(),
683  true_node_offsets.end(), node_id);
684  libmesh_assert(lb != true_node_offsets.end());
685  const processor_id_type p = lb - true_node_offsets.begin();
686 
687  return node_id + added_node_offsets[p];
688  };
689 
690  if (add_sides)
691  {
692  true_node_offsets.resize(n_proc);
693  added_node_offsets.resize(n_proc);
694 
695  // One loop to count everyone's new side nodes
696  for (const auto & elem : _mesh.active_element_ptr_range())
697  {
698  for (auto s : elem->side_index_range())
699  {
700  if (redundant_added_side(*elem,s))
701  continue;
702 
703  const std::vector<unsigned int> side_nodes =
704  elem->nodes_on_side(s);
705 
706  if (elem->processor_id() == this->processor_id())
707  local_added_side_nodes += side_nodes.size();
708  }
709  }
710 
711  others_added_side_nodes.resize(n_proc);
712  _mesh.comm().allgather(local_added_side_nodes,
713  others_added_side_nodes);
714 
715  added_side_nodes = std::accumulate(others_added_side_nodes.begin(),
716  others_added_side_nodes.end(), 0,
717  std::plus<>());
718 
719  _mesh.comm().allgather(n_local_nodes, true_node_offsets);
720  for (auto p : make_range(n_proc-1))
721  true_node_offsets[p+1] += true_node_offsets[p];
722  libmesh_assert_equal_to(true_node_offsets[n_proc-1], _mesh.max_node_id());
723 
724  // For nodes that exist in the mesh, we just need an offset to
725  // tell where to put their solutions.
726  added_node_offsets[0] = 0;
727  for (auto p : make_range(n_proc-1))
728  added_node_offsets[p+1] =
729  added_node_offsets[p] + others_added_side_nodes[p];
730 
731  // For added side nodes, we need to fill a map. Start after all
732  // the true node for our pid plus all the side nodes for
733  // previous pids
734  dof_id_type node_counter = true_node_offsets[my_pid];
735  for (auto p : make_range(my_pid))
736  node_counter += others_added_side_nodes[p];
737 
738  // One loop to figure out whose added side nodes get which index
739  for (const auto & elem : _mesh.active_local_element_ptr_range())
740  {
741  for (auto s : elem->side_index_range())
742  {
743  if (redundant_added_side(*elem,s))
744  continue;
745 
746  const std::vector<unsigned int> side_nodes =
747  elem->nodes_on_side(s);
748 
749  for (auto n : index_range(side_nodes))
750  discontinuous_node_indices
751  [std::make_tuple(elem->id(),s,n)] = node_counter++;
752  }
753  }
754  }
755 
756  const dof_id_type
757  n_global_vals = (max_nn + added_side_nodes) * nv,
758  n_local_vals = (n_local_nodes + local_added_side_nodes) * nv;
759 
760  // Create a NumericVector to hold the parallel solution
761  std::unique_ptr<NumericVector<Number>> parallel_soln_ptr = NumericVector<Number>::build(_communicator);
762  NumericVector<Number> & parallel_soln = *parallel_soln_ptr;
763  parallel_soln.init(n_global_vals, n_local_vals, false, PARALLEL);
764 
765  // Create a NumericVector to hold the "repeat_count" for each node - this is essentially
766  // the number of elements contributing to that node's value
767  std::unique_ptr<NumericVector<Number>> repeat_count_ptr = NumericVector<Number>::build(_communicator);
768  NumericVector<Number> & repeat_count = *repeat_count_ptr;
769  repeat_count.init(n_global_vals, n_local_vals, false, PARALLEL);
770 
771  repeat_count.close();
772 
773  unsigned int var_num=0;
774 
775  // For each system in this EquationSystems object,
776  // update the global solution and if we are on processor 0,
777  // loop over the elements and build the nodal solution
778  // from the element solution. Then insert this nodal solution
779  // into the vector passed to build_solution_vector.
780  for (const auto & [sys_name, sys_ptr] : _systems)
781  {
782  // Check current system is listed in system_names, and skip pos if not
783  bool use_current_system = (system_names == nullptr);
784  if (!use_current_system)
785  use_current_system = system_names->count(sys_name);
786  if (!use_current_system || sys_ptr->hide_output())
787  continue;
788 
789  const System & system = *sys_ptr;
790  const unsigned int nv_sys = system.n_vars();
791  const unsigned int sys_num = system.number();
792 
793  //Could this be replaced by a/some convenience methods?[PB]
794  unsigned int n_scalar_vars = 0;
795  unsigned int n_vector_vars = 0;
796  for (auto vn : make_range(sys_ptr->n_vars()))
797  {
798  if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
799  n_vector_vars++;
800  else
801  n_scalar_vars++;
802  }
803 
804  // Here, we're assuming the number of vector components is the same
805  // as the mesh spatial dimension.
806  unsigned int nv_sys_split = n_scalar_vars + dim*n_vector_vars;
807 
808  // Update the current_local_solution
809  {
810  System & non_const_sys = const_cast<System &>(system);
811  // We used to simply call non_const_sys.solution->close()
812  // here, but that is not allowed when the solution vector is
813  // locked read-only, for example when printing the solution
814  // during the middle of a solve... So try to be a bit
815  // more careful about calling close() unnecessarily.
816  libmesh_assert(this->comm().verify(non_const_sys.solution->closed()));
817  if (!non_const_sys.solution->closed())
818  non_const_sys.solution->close();
819  non_const_sys.update();
820  }
821 
822  NumericVector<Number> & sys_soln(*system.current_local_solution);
823 
824  const DofMap & dof_map = system.get_dof_map();
825 
826  std::vector<Number> elem_soln; // The finite element solution
827  std::vector<Number> nodal_soln; // The FE solution interpolated to the nodes
828  std::vector<dof_id_type> dof_indices; // The DOF indices for the finite element
829 
830  unsigned var_inc = 0;
831  for (unsigned int var=0; var<nv_sys; var++)
832  {
833  const FEType & fe_type = system.variable_type(var);
834  const Variable & var_description = system.variable(var);
835  unsigned int n_vec_dim = FEInterface::n_vec_dim( sys_ptr->get_mesh(), fe_type );
836  const auto vg = dof_map.var_group_from_var_number(var);
837  const bool add_p_level = dof_map.should_p_refine(vg);
838 
839  for (const auto & elem : _mesh.active_local_element_ptr_range())
840  {
841  if (var_description.active_on_subdomain(elem->subdomain_id()))
842  {
843  dof_map.dof_indices (elem, dof_indices, var);
844  sys_soln.get(dof_indices, elem_soln);
845 
846  FEInterface::nodal_soln (elem->dim(),
847  fe_type,
848  elem,
849  elem_soln,
850  nodal_soln,
851  add_p_level,
852  n_vec_dim);
853 
854  // infinite elements should be skipped...
855  if (!elem->infinite())
856  {
857  libmesh_assert_equal_to (nodal_soln.size(), n_vec_dim*elem->n_nodes());
858 
859  for (auto n : elem->node_index_range())
860  {
861  const Node & node = elem->node_ref(n);
862 
863  const dof_id_type node_idx =
864  nv * node_id_to_vec_id(node.id());
865 
866  for (unsigned int d=0; d < n_vec_dim; d++)
867  {
868  // For vector-valued elements, all components are in nodal_soln. For each
869  // node, the components are stored in order, i.e. node_0 -> s0_x, s0_y, s0_z
870  parallel_soln.add(node_idx + (var_inc+d + var_num), nodal_soln[n_vec_dim*n+d]);
871 
872  // Increment the repeat count for this position
873  repeat_count.add(node_idx + (var_inc+d + var_num), 1);
874  }
875  }
876 
877  if (add_sides)
878  {
879  for (auto s : elem->side_index_range())
880  {
881  if (redundant_added_side(*elem,s))
882  continue;
883 
884  // Compute the FE solution at all the
885  // side nodes
886  FEInterface::side_nodal_soln
887  (fe_type, elem, s, elem_soln,
888  nodal_soln, add_p_level, n_vec_dim);
889 
890 #ifdef DEBUG
891  const std::vector<unsigned int> side_nodes =
892  elem->nodes_on_side(s);
893 
894  libmesh_assert_equal_to
895  (nodal_soln.size(),
896  side_nodes.size());
897 #endif
898 
899  for (auto n : index_range(nodal_soln))
900  {
901  // Retrieve index into global solution vector.
902  std::size_t node_index =
903  nv * libmesh_map_find(discontinuous_node_indices,
904  std::make_tuple(elem->id(), s, n));
905 
906  for (unsigned int d=0; d < n_vec_dim; d++)
907  {
908  parallel_soln.add(node_index + (var_inc+d + var_num), nodal_soln[n_vec_dim*n+d]);
909  repeat_count.add(node_index + (var_inc+d + var_num), 1);
910  }
911  }
912  }
913  }
914  }
915  }
916  else // If this variable doesn't exist on this subdomain we have to still increment repeat_count so that we won't divide by 0 later:
917  for (auto n : elem->node_index_range())
918  {
919  const Node & node = elem->node_ref(n);
920  // Only do this if this variable has NO DoFs at
921  // this node... it might have some from an
922  // adjoining element...
923  if (!node.n_dofs(sys_num, var))
924  {
925  const dof_id_type node_idx =
926  nv * node_id_to_vec_id(node.id());
927 
928  for (unsigned int d=0; d < n_vec_dim; d++)
929  repeat_count.add(node_idx + (var_inc+d + var_num), 1);
930  }
931  }
932 
933  } // end loop over elements
934  var_inc += n_vec_dim;
935  } // end loop on variables in this system
936 
937  var_num += nv_sys_split;
938  } // end loop over systems
939 
940  // Sum the nodal solution values and repeat counts.
941  parallel_soln.close();
942  repeat_count.close();
943 
944  // If there were gaps in the node numbering, there will be
945  // corresponding zeros in the parallel_soln and repeat_count
946  // vectors. We need to set those repeat_count entries to 1
947  // in order to avoid dividing by zero.
948  if (n_gaps)
949  {
950  for (numeric_index_type i=repeat_count.first_local_index();
951  i<repeat_count.last_local_index(); ++i)
952  {
953  // repeat_count entries are integral values but let's avoid a
954  // direct floating point comparison with 0 just in case some
955  // roundoff noise crept in during vector assembly?
956  if (std::abs(repeat_count(i)) < TOLERANCE)
957  repeat_count.set(i, 1.);
958  }
959 
960  // Make sure the repeat_count vector is up-to-date on all
961  // processors.
962  repeat_count.close();
963  }
964 
965  // Divide to get the average value at the nodes
966  parallel_soln /= repeat_count;
967 
968  return parallel_soln_ptr;
969 }
TIMPI::Communicator::allgather
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
libMesh::TOLERANCE
static constexpr Real TOLERANCE
Definition: libmesh_common.h:151
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
TIMPI::Communicator::sum
void sum(T &r) const
libMesh::FEInterface::field_type
static FEFieldType field_type(const FEType &fe_type)
Definition: fe_interface.C:2642
TIMPI::Communicator::rank
processor_id_type rank() const
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition: parallel_object.h:97
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:120
distance
Real distance(const Point &p)
Definition: subdomains_ex3.C:51
libMesh::FEInterface::side_nodal_soln
static void side_nodal_soln(const FEType &fe_t, const Elem *elem, const unsigned int side, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln on one side from the (full) element soln.
Definition: fe_interface.C:650
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
TIMPI::Communicator::size
processor_id_type size() const
processor_id_type
uint8_t processor_id_type
libMesh::numeric_index_type
dof_id_type numeric_index_type
Definition: id_types.h:99
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::FEInterface::n_vec_dim
static unsigned int n_vec_dim(const MeshBase &mesh, const FEType &fe_type)
Definition: fe_interface.C:2677
libMesh::MeshBase::spatial_dimension
unsigned int spatial_dimension() const
Definition: mesh_base.C:543
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
libMesh::NumericVector::build
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
Builds a NumericVector on the processors in communicator comm using the linear solver package specifi...
Definition: numeric_vector.C:61
libMesh::MeshBase::max_node_id
virtual dof_id_type max_node_id() const =0
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114
libMesh::FEInterface::nodal_soln
static void nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln from the element soln.
Definition: fe_interface.C:625
libMesh::NumericVector< Number >
template class LIBMESH_EXPORT NumericVector< Number >
Definition: numeric_vector.C:704
libMesh::index_range
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
libMesh::dof_id_type
uint8_t dof_id_type
Definition: id_types.h:67
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611
libMesh::EquationSystems::redundant_added_side
static bool redundant_added_side(const Elem &elem, unsigned int side)
Definition: equation_systems.C:1577

◆ build_solution_vector() [1/2]

void libMesh::EquationSystems::build_solution_vector ( std::vector< Number > &  soln,
std::string_view  system_name,
std::string_view  variable_name = "all_vars" 
) const
inherited

Fill the input vector soln with the solution values for the system named name.

Note
The input vector soln will only be assembled on processor 0, so this method is only applicable to outputting plot files from processor 0.

Definition at line 569 of file equation_systems.C.

Referenced by libMesh::MeshOutput< MeshBase >::write_equation_systems().

572 {
573  // TODO:[BSK] re-implement this from the method below
574  libmesh_not_implemented();
575 }

◆ build_solution_vector() [2/2]

void libMesh::EquationSystems::build_solution_vector ( std::vector< Number > &  soln,
const std::set< std::string > *  system_names = nullptr,
bool  add_sides = false 
) const
inherited

Fill the input vector soln with solution values.

The entries will be in variable-major format (corresponding to the names from build_variable_names()).

If systems_names!=nullptr, only include data from the specified systems.

If add_sides is true, append data for plotting on "side elements" too.

Definition at line 973 of file equation_systems.C.

References libMesh::EquationSystems::build_parallel_solution_vector().

976 {
977  LOG_SCOPE("build_solution_vector()", "EquationSystems");
978 
979  // Call the parallel implementation
980  std::unique_ptr<NumericVector<Number>> parallel_soln =
981  this->build_parallel_solution_vector(system_names, add_sides);
982 
983  // Localize the NumericVector into the provided std::vector.
984  parallel_soln->localize_to_one(soln);
985 }
libMesh::EquationSystems::build_parallel_solution_vector
std::unique_ptr< NumericVector< Number > > build_parallel_solution_vector(const std::set< std::string > *system_names=nullptr, bool add_sides=false) const
A version of build_solution_vector which is appropriate for "parallel" output formats like Nemesis...
Definition: equation_systems.C:581

◆ build_variable_names()

void libMesh::EquationSystems::build_variable_names ( std::vector< std::string > &  var_names,
const FEType *  type = nullptr,
const std::set< std::string > *  system_names = nullptr 
) const
inherited

Fill the input vector var_names with the names of the variables for each system.

If type is passed, only variables of the specified type will be populated. If systems_names!=nullptr, only include names from the specified systems.

Definition at line 450 of file equation_systems.C.

References libMesh::EquationSystems::_systems, dim, libMesh::FEInterface::field_type(), libMesh::EquationSystems::get_mesh(), libMesh::make_range(), libMesh::EquationSystems::n_vars(), libMesh::FEInterface::n_vec_dim(), libMesh::MeshBase::spatial_dimension(), and libMesh::TYPE_VECTOR.

Referenced by main(), EquationSystemsTest::testBadVarNames(), libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems(), libMesh::ExodusII_IO::write_discontinuous_exodusII(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::Nemesis_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::MeshOutput< MeshBase >::write_equation_systems(), libMesh::Nemesis_IO::write_nodal_data(), and libMesh::MeshOutput< MeshBase >::write_nodal_data().

453 {
454  // start indexing at end of possibly non-empty vector of variable names to avoid overwriting them
455  unsigned int var_num = var_names.size();
456 
457  // We'll want to double-check that we don't have any naming
458  // conflicts; this API causes problems down the line if so.
459  std::unordered_multiset<std::string> seen_names;
460 
461  // Need to size var_names by scalar variables plus all the
462  // vector components for all the vector variables
463  //Could this be replaced by a/some convenience methods?[PB]
464  {
465  unsigned int n_scalar_vars = 0;
466  unsigned int n_vector_vars = 0;
467 
468  for (const auto & [sys_name, sys_ptr] : _systems)
469  {
470  // Check current system is listed in system_names, and skip pos if not
471  bool use_current_system = (system_names == nullptr);
472  if (!use_current_system)
473  use_current_system = system_names->count(sys_name);
474  if (!use_current_system || sys_ptr->hide_output())
475  {
476  for (auto vn : make_range(sys_ptr->n_vars()))
477  seen_names.insert(sys_ptr->variable_name(vn));
478  continue;
479  }
480 
481  for (auto vn : make_range(sys_ptr->n_vars()))
482  {
483  seen_names.insert(sys_ptr->variable_name(vn));
484  if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
485  n_vector_vars++;
486  else
487  n_scalar_vars++;
488  }
489  }
490 
491  // Here, we're assuming the number of vector components is the same
492  // as the mesh spatial dimension.
493  unsigned int dim = this->get_mesh().spatial_dimension();
494  unsigned int nv = n_scalar_vars + dim*n_vector_vars;
495 
496  // We'd better not have more than dim*this->n_vars() (all vector variables)
497  // Treat the NodeElem-only mesh case as dim=1
498  libmesh_assert_less_equal ( nv, (dim > 0 ? dim : 1)*this->n_vars() );
499 
500  // 'nv' represents the max possible number of output variables, so allocate enough memory for
501  // all variables in the system to be populated here. When this is called more than once on a
502  // single 'var_names' vector, different filters should be used such that duplicates don't occur.
503  var_names.resize( nv );
504  }
505 
506  for (const auto & [sys_name, sys_ptr] : _systems)
507  {
508  // Check current system is listed in system_names, and skip pos if not
509  bool use_current_system = (system_names == nullptr);
510  if (!use_current_system)
511  use_current_system = system_names->count(sys_name);
512  if (!use_current_system || sys_ptr->hide_output())
513  continue;
514 
515  for (auto vn : make_range(sys_ptr->n_vars()))
516  {
517  const std::string & var_name = sys_ptr->variable_name(vn);
518  const FEType & fe_type = sys_ptr->variable_type(vn);
519 
520  unsigned int n_vec_dim = FEInterface::n_vec_dim( sys_ptr->get_mesh(), fe_type);
521 
522  // Filter on the type if requested
523  if (type == nullptr || (type && *type == fe_type))
524  {
525  if (FEInterface::field_type(fe_type) == TYPE_VECTOR)
526  {
527  switch(n_vec_dim)
528  {
529  case 0:
530  case 1:
531  var_names[var_num++] = var_name;
532  libmesh_error_msg_if(seen_names.count(var_name) > 1,
533  "Duplicate variable name "+var_name);
534  break;
535  case 2:
536  var_names[var_num++] = var_name+"_x";
537  var_names[var_num++] = var_name+"_y";
538  libmesh_error_msg_if(seen_names.count(var_name+"_x"),
539  "Duplicate variable name "+var_name+"_x");
540  libmesh_error_msg_if(seen_names.count(var_name+"_y"),
541  "Duplicate variable name "+var_name+"_y");
542  break;
543  case 3:
544  var_names[var_num++] = var_name+"_x";
545  var_names[var_num++] = var_name+"_y";
546  var_names[var_num++] = var_name+"_z";
547  libmesh_error_msg_if(seen_names.count(var_name+"_x"),
548  "Duplicate variable name "+var_name+"_x");
549  libmesh_error_msg_if(seen_names.count(var_name+"_y"),
550  "Duplicate variable name "+var_name+"_y");
551  libmesh_error_msg_if(seen_names.count(var_name+"_z"),
552  "Duplicate variable name "+var_name+"_z");
553  break;
554  default:
555  libmesh_error_msg("Invalid dim in build_variable_names");
556  }
557  }
558  else
559  var_names[var_num++] = var_name;
560  }
561  }
562  }
563  // Now resize again in case we filtered any names
564  var_names.resize(var_num);
565 }
libMesh::EquationSystems::n_vars
unsigned int n_vars() const
Definition: equation_systems.C:1707
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
libMesh::FEInterface::field_type
static FEFieldType field_type(const FEType &fe_type)
Definition: fe_interface.C:2642
libMesh::FEInterface::n_vec_dim
static unsigned int n_vec_dim(const MeshBase &mesh, const FEType &fe_type)
Definition: fe_interface.C:2677
libMesh::MeshBase::spatial_dimension
unsigned int spatial_dimension() const
Definition: mesh_base.C:543
libMesh::EquationSystems::get_mesh
const MeshBase & get_mesh() const
Definition: equation_systems.h:646
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ clear()

void libMesh::EquationSystems::clear ( )
virtualinherited

Restores the data structure to a pristine state.

Definition at line 69 of file equation_systems.C.

References libMesh::EquationSystems::_systems, libMesh::Parameters::clear(), and libMesh::EquationSystems::parameters.

Referenced by main().

70 {
71  // Clear any additional parameters
72  parameters.clear ();
73 
74  // Clear the systems.
75  _systems.clear();
76 }
libMesh::Parameters::clear
virtual void clear()
Clears internal data structures & frees any allocated memory.
Definition: parameters.h:324
libMesh::EquationSystems::parameters
Parameters parameters
Data structure holding arbitrary parameters.
Definition: equation_systems.h:597
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::System::get_info(), libMesh::DofMap::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), VolumeTest::testC0PolygonMethods(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

98  { return _communicator; }
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:120

◆ compare()

bool libMesh::EquationSystems::compare ( const EquationSystems &  other_es,
const Real  threshold,
const bool  verbose 
) const
virtualinherited
Returns
true when this equation system contains identical data, up to the given threshold. Delegates most of the comparisons to perform to the responsible systems

Definition at line 1602 of file equation_systems.C.

References libMesh::EquationSystems::_systems, libMesh::EquationSystems::get_system(), libMesh::EquationSystems::n_systems(), and libMesh::out.

Referenced by do_compare().

1605 {
1606  // safety check, whether we handle at least the same number
1607  // of systems
1608  std::vector<bool> os_result;
1609 
1610  if (this->n_systems() != other_es.n_systems())
1611  {
1612  if (verbose)
1613  {
1614  libMesh::out << " Fatal difference. This system handles "
1615  << this->n_systems() << " systems," << std::endl
1616  << " while the other system handles "
1617  << other_es.n_systems()
1618  << " systems." << std::endl
1619  << " Aborting comparison." << std::endl;
1620  }
1621  return false;
1622  }
1623  else
1624  {
1625  // start comparing each system
1626  for (const auto & [sys_name, sys_ptr] : _systems)
1627  {
1628  // get the other system
1629  const System & other_system = other_es.get_system (sys_name);
1630 
1631  os_result.push_back (sys_ptr->compare (other_system, threshold, verbose));
1632 
1633  }
1634 
1635  }
1636 
1637 
1638  // sum up the results
1639  if (os_result.size()==0)
1640  return true;
1641  else
1642  {
1643  bool os_identical;
1644  unsigned int n = 0;
1645  do
1646  {
1647  os_identical = os_result[n];
1648  n++;
1649  }
1650  while (os_identical && n<os_result.size());
1651  return os_identical;
1652  }
1653 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::out
OStreamProxy out
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
Definition: reference_counter.h:143

◆ disable_refine_in_reinit()

void libMesh::EquationSystems::disable_refine_in_reinit ( )
inlineinherited

Calls to reinit() will not try to coarsen or refine the mesh.

Definition at line 574 of file equation_systems.h.

References libMesh::EquationSystems::_refine_in_reinit.

Referenced by EquationSystemsTest::testRefineThenReinitPreserveFlags(), and EquationSystemsTest::testSelectivePRefine().

574 { this->_refine_in_reinit = false; }
libMesh::EquationSystems::_refine_in_reinit
bool _refine_in_reinit
Flag for whether to call coarsen/refine in reinit().
Definition: equation_systems.h:617

◆ dt()

Real Biharmonic::dt ( )
inline

Definition at line 81 of file biharmonic.h.

References _dt.

81 { return _dt; }

◆ dt0()

Real Biharmonic::dt0 ( )
inline

Definition at line 80 of file biharmonic.h.

References _dt0.

80 { return _dt0; }

◆ enable_default_ghosting()

void libMesh::EquationSystems::enable_default_ghosting ( bool  enable)
virtualinherited

Enable or disable default ghosting functors on the Mesh and on all Systems.

Standard ghosting is enabled by default. If disabled, default ghosting will also be disabled on any later added systems.

Unless other equivalent ghosting functors have been added, removing the default coupling functor is only safe for explicit solves, and removing the default algebraic ghosting functor is only safe for codes where no evaluations on neighbor cells (e.g. no jump error estimators) are done.

Definition at line 305 of file equation_systems.C.

References libMesh::EquationSystems::_enable_default_ghosting, libMesh::DofMap::add_default_ghosting(), libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::make_range(), mesh, libMesh::EquationSystems::n_systems(), and libMesh::DofMap::remove_default_ghosting().

Referenced by EquationSystemsTest::testDisableDefaultGhosting().

306 {
307  _enable_default_ghosting = enable;
308  MeshBase &mesh = this->get_mesh();
309 
310  if (enable)
311  mesh.add_ghosting_functor(mesh.default_ghosting());
312  else
313  mesh.remove_ghosting_functor(mesh.default_ghosting());
314 
315  for (auto i : make_range(this->n_systems()))
316  {
317  DofMap & dof_map = this->get_system(i).get_dof_map();
318  if (enable)
319  dof_map.add_default_ghosting();
320  else
321  dof_map.remove_default_ghosting();
322  }
323 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::_enable_default_ghosting
bool _enable_default_ghosting
Flag for whether to enable default ghosting on newly added Systems.
Definition: equation_systems.h:623
mesh
MeshBase & mesh
Definition: mesh_communication.C:1476
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::get_mesh
const MeshBase & get_mesh() const
Definition: equation_systems.h:646
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

Methods to enable/disable the reference counter output from print_info()

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
Definition: reference_counter.h:143

◆ enable_refine_in_reinit()

void libMesh::EquationSystems::enable_refine_in_reinit ( )
inlineinherited

Calls to reinit() will also do two-step coarsen-then-refine.

Definition at line 569 of file equation_systems.h.

References libMesh::EquationSystems::_refine_in_reinit.

569 { this->_refine_in_reinit = true; }
libMesh::EquationSystems::_refine_in_reinit
bool _refine_in_reinit
Flag for whether to call coarsen/refine in reinit().
Definition: equation_systems.h:617

◆ find_variable_numbers()

std::vector< std::pair< unsigned int, unsigned int > > libMesh::EquationSystems::find_variable_numbers ( std::vector< std::string > &  names,
const FEType *  type = nullptr,
const std::vector< FEType > *  types = nullptr 
) const
inherited

Finds system and variable numbers for any variables of 'type' or of 'types' corresponding to the entries in the input 'names' vector.

If 'names' is empty, this returns all variables of the type. The names of vector variables are decomposed into individual ones suffixed with their cartesian component, but there will still be a single pair of system numbers for such vector variables. Thus, the size of the 'names' vector modified by this function may not be equal to that of the returned vector of pairs. Nevertheless, both should be sorted in accordance with ExodusII format, and so the developer just needs to know to separate dof_indices when accessing the system solution for vector variables.

This function is designed to work for either a single type or a vector of types, but not both. This is because it can't simply be called a second time with another type as it filters (deletes) the names of those on the first call that used a different type. Thus, the 'types' argument is for the case where variables of multiple types are allowed to pass through.

TODO: find a more generic way to handle this whole procedure.

Definition at line 1046 of file equation_systems.C.

References dim, libMesh::FEInterface::field_type(), libMesh::index_range(), libMesh::Utility::iota(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::System::n_vars(), libMesh::Quality::name(), libMesh::System::number(), libMesh::TYPE_VECTOR, libMesh::System::variable_name(), and libMesh::System::variable_type().

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::Nemesis_IO::write_element_data(), and libMesh::Nemesis_IO::write_nodal_data().

1047 {
1048  // This function must be run on all processors at once
1049  parallel_object_only();
1050 
1051  libmesh_assert (this->n_systems());
1052 
1053  // Resolve class of type input and assert that at least one of them is null
1054  libmesh_assert_msg(!type || !types,
1055  "Input 'type', 'types', or neither in find_variable_numbers, but not both.");
1056 
1057  std::vector<FEType> type_filter;
1058  if (type)
1059  type_filter.push_back(*type);
1060  else if (types)
1061  type_filter = *types;
1062 
1063  // Store a copy of the valid variable names, if any. The names vector will be repopulated with any
1064  // valid names (or all if 'is_names_empty') in the system that passes through the type filter. If
1065  // the variable is a vector, its name will be decomposed into its separate components in
1066  // accordance with build_variable_names().
1067  std::vector<std::string> name_filter = names;
1068  bool is_names_empty = name_filter.empty();
1069  names.clear();
1070 
1071  // initialize convenience variables
1072  FEType var_type;
1073  std::string name;
1074 
1075  const std::vector<std::string> component_suffix = {"_x", "_y", "_z"};
1076  unsigned int dim = _mesh.spatial_dimension();
1077  libmesh_error_msg_if(dim > 3, "Invalid dim in find_variable_numbers");
1078 
1079  // Now filter through the variables in each system and store the system index and their index
1080  // within that system. This way, we know where to find their data even after we sort them.
1081  std::vector<std::pair<unsigned int, unsigned int>> var_nums;
1082 
1083  for (const auto & pr : _systems)
1084  {
1085  const System & system = *(pr.second);
1086 
1087  for (auto var : make_range(system.n_vars()))
1088  {
1089  // apply the type filter
1090  var_type = system.variable_type(var);
1091  if (type_filter.size() &&
1092  std::find(type_filter.begin(), type_filter.end(), var_type) == type_filter.end())
1093  continue;
1094 
1095  // apply the name filter (note that all variables pass if it is empty)
1096  if (FEInterface::field_type(var_type) == TYPE_VECTOR)
1097  {
1098  std::vector<std::string> component_names;
1099  for (unsigned int comp = 0; comp < dim; ++comp)
1100  {
1101  name = system.variable_name(var) + component_suffix[comp];
1102  if (is_names_empty ||
1103  (std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end()))
1104  component_names.push_back(name);
1105  }
1106 
1107  if (! component_names.empty())
1108  names.insert(names.end(), component_names.begin(), component_names.end());
1109  else
1110  continue;
1111  }
1112  else /*scalar-valued variable*/
1113  {
1114  name = system.variable_name(var);
1115  if (is_names_empty ||
1116  (std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end()))
1117  names.push_back(name);
1118  else
1119  continue;
1120  }
1121 
1122  // if the variable made it through both filters get its system indices
1123  var_nums.emplace_back(system.number(), var);
1124  }
1125  }
1126 
1127  // Sort the var_nums vector pairs alphabetically based on the variable name
1128  std::vector<unsigned int> sort_index(var_nums.size());
1129  std::iota(sort_index.begin(), sort_index.end(), 0);
1130  std::sort(sort_index.begin(), sort_index.end(),
1131  [&](const unsigned int & lhs, const unsigned int & rhs)
1132  {return this->get_system(var_nums[lhs].first).variable_name(var_nums[lhs].second) <
1133  this->get_system(var_nums[rhs].first).variable_name(var_nums[rhs].second);});
1134 
1135  std::vector<std::pair<unsigned int, unsigned int>> var_nums_sorted(var_nums.size());
1136  for (auto i : index_range(var_nums_sorted))
1137  {
1138  var_nums_sorted[i].first = var_nums[sort_index[i]].first;
1139  var_nums_sorted[i].second = var_nums[sort_index[i]].second;
1140  }
1141 
1142  // Also sort the names vector
1143  std::sort(names.begin(), names.end());
1144 
1145  // Return the sorted vector pairs
1146  return var_nums_sorted;
1147 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
libMesh::FEInterface::field_type
static FEFieldType field_type(const FEType &fe_type)
Definition: fe_interface.C:2642
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::Utility::iota
void iota(ForwardIter first, ForwardIter last, T value)
Utility::iota was created back when std::iota was just an SGI STL extension.
Definition: utility.h:229
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::MeshBase::spatial_dimension
unsigned int spatial_dimension() const
Definition: mesh_base.C:543
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
libMesh::index_range
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:117
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_info() [1/2]

std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition: reference_counter.h:124

◆ get_info() [2/2]

std::string libMesh::EquationSystems::get_info ( ) const
virtualinherited
Returns
A string containing information about the systems, flags, and parameters.

Definition at line 1657 of file equation_systems.C.

References libMesh::EquationSystems::_systems, and libMesh::EquationSystems::n_systems().

Referenced by libMesh::EquationSystems::print_info().

1658 {
1659  std::ostringstream oss;
1660 
1661  oss << " EquationSystems\n"
1662  << " n_systems()=" << this->n_systems() << '\n';
1663 
1664  // Print the info for the individual systems
1665  for (const auto & pr : _systems)
1666  oss << pr.second->get_info();
1667 
1668 
1669  // // Possibly print the parameters
1670  // if (!this->parameters.empty())
1671  // {
1672  // oss << " n_parameters()=" << this->n_parameters() << '\n';
1673  // oss << " Parameters:\n";
1674 
1675  // for (const auto & [key, val] : _parameters)
1676  // oss << " "
1677  // << "\""
1678  // << key
1679  // << "\""
1680  // << "="
1681  // << val
1682  // << '\n';
1683  // }
1684 
1685  return oss.str();
1686 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_mesh() [1/2]

const MeshBase & libMesh::EquationSystems::get_mesh ( ) const
inlineinherited
Returns
A constant reference to the mesh

Definition at line 646 of file equation_systems.h.

References libMesh::EquationSystems::_mesh.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), alternative_fe_assembly(), assemble(), LinearElasticity::assemble(), assemble_1D(), assemble_biharmonic(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_graddiv(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_matrix_and_rhs(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), assembly_with_dg_fem_context(), libMesh::EquationSystems::build_variable_names(), compute_stresses(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::EquationSystems::enable_default_ghosting(), libMesh::AdjointRefinementEstimator::estimate_error(), fe_assembly(), fill_dirichlet_bc(), libMesh::MeshFunction::init(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), periodic_bc_test_poisson(), libMesh::EquationSystems::read(), libMesh::EquationSystems::reinit_solutions(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), run_timestepping(), scale_mesh_and_plot(), libMesh::DirectSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), transform_mesh_and_plot(), libMesh::EquationSystems::write(), libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems(), libMesh::MeshOutput< MeshBase >::write_equation_systems(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), write_output(), and write_output_solvedata().

647 {
648  return _mesh;
649 }
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606

◆ get_mesh() [2/2]

MeshBase & libMesh::EquationSystems::get_mesh ( )
inlineinherited
Returns
A reference to the mesh

Definition at line 654 of file equation_systems.h.

References libMesh::EquationSystems::_mesh.

655 {
656  return _mesh;
657 }
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606

◆ get_solution()

void libMesh::EquationSystems::get_solution ( std::vector< Number > &  soln,
std::vector< std::string > &  names 
) const
inherited

Retrieve the solution data for CONSTANT MONOMIALs and/or components of CONSTANT MONOMIAL_VECs.

If 'names' is populated, only the variables corresponding to those names will be retrieved. This can be used to filter which variables are retrieved.

Deprecated:
Call the more appropriately-named build_elemental_solution_vector() instead.

Definition at line 1016 of file equation_systems.C.

References libMesh::EquationSystems::build_elemental_solution_vector().

1018 {
1019  libmesh_deprecated();
1020  this->build_elemental_solution_vector(soln, names);
1021 }
libMesh::EquationSystems::build_elemental_solution_vector
void build_elemental_solution_vector(std::vector< Number > &soln, std::vector< std::string > &names) const
Retrieve the solution data for CONSTANT MONOMIALs and/or components of CONSTANT MONOMIAL_VECs.
Definition: equation_systems.C:1027

◆ get_system() [1/8]

template<typename T_sys >
const T_sys & libMesh::EquationSystems::get_system ( std::string_view  name) const
inlineinherited
Returns
A constant reference to the system named name. The template argument defines the return type. For example, const SteadySystem & sys = eq.get_system<SteadySystem> ("sys"); is an example of how the method might be used

Definition at line 757 of file equation_systems.h.

References libMesh::EquationSystems::_systems, and libMesh::Quality::name().

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::_remove_default_ghosting(), add_M_C_K_helmholtz(), libMesh::EnsightIO::add_scalar(), libMesh::RBSCMConstruction::add_scaled_symm_Aq(), libMesh::EquationSystems::add_system(), libMesh::EnsightIO::add_vector(), libMesh::EquationSystems::adjoint_solve(), libMesh::EquationSystems::allgather(), alternative_fe_assembly(), apply_initial(), assemble(), LinearElasticity::assemble(), assemble_1D(), assemble_biharmonic(), assemble_cd(), assemble_divgrad(), assemble_elasticity(), assemble_ellipticdg(), assemble_func(), assemble_graddiv(), assemble_helmholtz(), assemble_laplace(), assemble_mass(), assemble_matrices(), assemble_matrix_and_rhs(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), assembly_with_dg_fem_context(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::compare(), libMesh::ExactSolution::compute_error(), compute_stresses(), LinearElasticityWithContact::compute_stresses(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::GMVIO::copy_nodal_solution(), SolidSystem::element_time_derivative(), libMesh::EquationSystems::enable_default_ghosting(), libMesh::ExactSolution::error_norm(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), fe_assembly(), fill_dirichlet_bc(), libMesh::DTKAdapter::find_sys(), form_functionA(), form_functionB(), form_matrixA(), libMesh::EquationSystems::init(), init_cd(), SolidSystem::init_data(), init_sys(), initialize(), LaplaceYoung::jacobian(), LargeDeformationElasticity::jacobian(), line_print(), libMesh::RBSCMConstruction::load_matrix_B(), main(), libMesh::RBSCMConstruction::perform_SCM_greedy(), periodic_bc_test_poisson(), libMesh::EquationSystems::read(), libMesh::EquationSystems::reinit_mesh(), libMesh::EquationSystems::reinit_solutions(), libMesh::EquationSystems::reinit_systems(), LaplaceYoung::residual(), LargeDeformationElasticity::residual(), run_timestepping(), SolidSystem::save_initial_mesh(), libMesh::EquationSystems::sensitivity_solve(), set_initial_condition(), SolidSystem::side_time_derivative(), libMesh::EquationSystems::solve(), MixedDimensionMeshTest::testDofOrdering(), MixedDimensionRefinedMeshTest::testDofOrdering(), MixedDimensionNonUniformRefinement::testDofOrdering(), MixedDimensionNonUniformRefinementTriangle::testDofOrdering(), MixedDimensionNonUniformRefinement3D::testDofOrdering(), SlitMeshRefinedSystemTest::testRestart(), libMesh::EquationSystems::update(), libMesh::Nemesis_IO_Helper::write_element_values(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

758 {
759  auto pos = _systems.find(name);
760 
761  // Check for errors
762  libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named \"" << name << "\" found!");
763 
764  // Attempt dynamic cast
765  const auto & sys_ptr = pos->second;
766  return cast_ref<const T_sys &>(*sys_ptr);
767 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_system() [2/8]

template<typename T_sys >
T_sys & libMesh::EquationSystems::get_system ( std::string_view  name)
inlineinherited
Returns
A writable reference to the system named name. The template argument defines the return type. For example, const SteadySystem & sys = eq.get_system<SteadySystem> ("sys"); is an example of how the method might be used

Definition at line 776 of file equation_systems.h.

References libMesh::EquationSystems::_systems, and libMesh::Quality::name().

777 {
778  auto pos = _systems.find(name);
779 
780  // Check for errors
781  libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named " << name << " found!");
782 
783  // Attempt dynamic cast
784  auto & sys_ptr = pos->second;
785  return cast_ref<T_sys &>(*sys_ptr);
786 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_system() [3/8]

template<typename T_sys >
const T_sys & libMesh::EquationSystems::get_system ( const unsigned int  num) const
inlineinherited
Returns
A constant reference to system number num. The template argument defines the return type. For example, const SteadySystem & sys = eq.get_system<SteadySystem> (0); is an example of how the method might be used

Definition at line 716 of file equation_systems.h.

References libMesh::EquationSystems::_systems, and libMesh::EquationSystems::n_systems().

717 {
718  libmesh_assert_less (num, this->n_systems());
719 
720  for (auto & pr : _systems)
721  {
722  const auto & sys_ptr = pr.second;
723  if (sys_ptr->number() == num)
724  return cast_ref<const T_sys &>(*sys_ptr);
725  }
726  // Error if we made it here
727  libmesh_error_msg("ERROR: no system number " << num << " found!");
728 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_system() [4/8]

template<typename T_sys >
T_sys & libMesh::EquationSystems::get_system ( const unsigned int  num)
inlineinherited
Returns
A writable reference to the system number num. The template argument defines the return type. For example, const SteadySystem & sys = eq.get_system<SteadySystem> (0); is an example of how the method might be used

Definition at line 735 of file equation_systems.h.

References libMesh::EquationSystems::_systems, and libMesh::EquationSystems::n_systems().

736 {
737  libmesh_assert_less (num, this->n_systems());
738 
739  for (auto & pr : _systems)
740  {
741  auto & sys_ptr = pr.second;
742  if (sys_ptr->number() == num)
743  return cast_ref<T_sys &>(*sys_ptr);
744  }
745 
746  // Error if we made it here
747  libmesh_error_msg("ERROR: no system number " << num << " found!");
748 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ get_system() [5/8]

const System & libMesh::EquationSystems::get_system ( std::string_view  name) const
inlineinherited
Returns
A constant reference to the system named name.

Definition at line 795 of file equation_systems.h.

References libMesh::Quality::name().

796 {
797  return this->get_system<System>(name);
798 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42

◆ get_system() [6/8]

System & libMesh::EquationSystems::get_system ( std::string_view  name)
inlineinherited
Returns
A writable reference to the system named name.

Definition at line 803 of file equation_systems.h.

References libMesh::Quality::name().

804 {
805  return this->get_system<System>(name);
806 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42

◆ get_system() [7/8]

const System & libMesh::EquationSystems::get_system ( const unsigned int  num) const
inlineinherited
Returns
A constant reference to system number num.

Definition at line 811 of file equation_systems.h.

812 {
813  return this->get_system<System>(num);
814 }

◆ get_system() [8/8]

System & libMesh::EquationSystems::get_system ( const unsigned int  num)
inlineinherited
Returns
A writable reference to the system number num.

Definition at line 819 of file equation_systems.h.

820 {
821  return this->get_system<System>(num);
822 }

◆ get_vars_active_subdomains()

void libMesh::EquationSystems::get_vars_active_subdomains ( const std::vector< std::string > &  names,
std::vector< std::set< subdomain_id_type >> &  vars_active_subdomains 
) const
inherited

Retrieve vars_active_subdomains, which indicates the active subdomains for each variable in names.

Definition at line 989 of file equation_systems.C.

References libMesh::EquationSystems::_systems, libMesh::Variable::active_subdomains(), distance(), and libMesh::make_range().

Referenced by libMesh::Nemesis_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data(), and libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data().

991 {
992  vars_active_subdomains.clear();
993  vars_active_subdomains.resize(names.size());
994 
995  for (const auto & pr : _systems)
996  {
997  const auto & sys_ptr = pr.second;
998  for (auto vn : make_range(sys_ptr->n_vars()))
999  {
1000  const std::string & var_name = sys_ptr->variable_name(vn);
1001 
1002  auto names_it = std::find(names.begin(), names.end(), var_name);
1003  if(names_it != names.end())
1004  {
1005  const Variable & variable = sys_ptr->variable(vn);
1006  const std::set<subdomain_id_type> & active_subdomains = variable.active_subdomains();
1007  vars_active_subdomains[std::distance(names.begin(), names_it)] = active_subdomains;
1008  }
1009  }
1010  }
1011 }
distance
Real distance(const Point &p)
Definition: subdomains_ex3.C:51
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ has_system()

bool libMesh::EquationSystems::has_system ( std::string_view  name) const
inlineinherited
Returns
true if the system named name exists within this EquationSystems object.

Definition at line 704 of file equation_systems.h.

References libMesh::EquationSystems::_systems, and libMesh::Quality::name().

Referenced by libMesh::EnsightIO::add_scalar(), libMesh::EnsightIO::add_vector(), libMesh::ExactSolution::compute_error(), libMesh::ExactSolution::error_norm(), and main().

705 {
706  if (_systems.find(name) == _systems.end())
707  return false;
708  return true;
709 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::err
OStreamProxy err
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition: reference_counter.h:124
libMesh::BasicOStreamProxy::get
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
Definition: ostream_proxy.h:217
libMesh::Threads::spin_mtx
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::err
OStreamProxy err
libMesh::ReferenceCounter::_counts
static Counts _counts
Actually holds the data.
Definition: reference_counter.h:124
libMesh::BasicOStreamProxy::get
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
Definition: ostream_proxy.h:217
libMesh::Threads::spin_mtx
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ init()

void Biharmonic::init ( )
virtual

Initialize all the systems.

Reimplemented from libMesh::EquationSystems.

Definition at line 212 of file biharmonic.C.

References _dt, _jr, _o_count, _verbose, libMesh::TriangleWrapper::init(), and libMesh::out.

213 {
214  // Build the main equation encapsulated in the JR (Jacobian-Residual or J(R) "jet of R") object
215  _jr = &(add_system<Biharmonic::JR>(std::string("Biharmonic::JR")));
216 
217  if (_verbose)
218  libMesh::out << ">>> Initializing Biharmonic\n";
219 
220  _dt = 0;
221  _o_count = 0;
222  EquationSystems::init();
223 
224  if (_verbose)
225  libMesh::out << "<<< Initializing Biharmonic\n";
226 }
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98
Biharmonic::_o_count
int _o_count
Definition: biharmonic.h:108
libMesh::TriangleWrapper::init
void init(triangulateio &t)
Initializes the fields of t to nullptr/0 as necessary.
libMesh::out
OStreamProxy out

◆ n_active_dofs()

std::size_t libMesh::EquationSystems::n_active_dofs ( ) const
inherited
Returns
The number of active degrees of freedom for the EquationSystems object.

Definition at line 1732 of file equation_systems.C.

References libMesh::EquationSystems::_systems.

Referenced by main(), and write_output_solvedata().

1733 {
1734  std::size_t tot=0;
1735 
1736  for (const auto & pr : _systems)
1737  tot += pr.second->n_active_dofs();
1738 
1739  return tot;
1740 }
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ n_dofs()

std::size_t libMesh::EquationSystems::n_dofs ( ) const
inherited
Returns
The total number of degrees of freedom in all systems.

Definition at line 1719 of file equation_systems.C.

References libMesh::EquationSystems::_systems.

Referenced by Biharmonic::JR::bounds(), and Biharmonic::JR::residual_and_jacobian().

1720 {
1721  std::size_t tot=0;
1722 
1723  for (const auto & pr : _systems)
1724  tot += pr.second->n_dofs();
1725 
1726  return tot;
1727 }
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

86  { return _n_objects; }
libMesh::ReferenceCounter::_n_objects
static Threads::atomic< unsigned int > _n_objects
The number of objects.
Definition: reference_counter.h:132

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
The number of processors in the group.

Definition at line 103 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and TIMPI::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:120
TIMPI::Communicator::size
processor_id_type size() const
processor_id_type
uint8_t processor_id_type
libMesh::libmesh_assert
libmesh_assert(ctx)

◆ n_systems()

unsigned int libMesh::EquationSystems::n_systems ( ) const
inlineinherited
Returns
The number of equation systems.

Definition at line 661 of file equation_systems.h.

References libMesh::EquationSystems::_systems.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::EquationSystems::add_system(), libMesh::EquationSystems::adjoint_solve(), libMesh::EquationSystems::allgather(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), libMesh::EquationSystems::compare(), libMesh::GMVIO::copy_nodal_solution(), libMesh::EquationSystems::enable_default_ghosting(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), libMesh::DTKAdapter::find_sys(), libMesh::EquationSystems::get_info(), libMesh::EquationSystems::get_system(), libMesh::EquationSystems::init(), main(), libMesh::EquationSystems::reinit_mesh(), libMesh::EquationSystems::reinit_solutions(), libMesh::EquationSystems::reinit_systems(), libMesh::EquationSystems::sensitivity_solve(), libMesh::EquationSystems::solve(), and libMesh::EquationSystems::update().

662 {
663  return cast_int<unsigned int>(_systems.size());
664 }
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ n_vars()

unsigned int libMesh::EquationSystems::n_vars ( ) const
inherited
Returns
The total number of variables in all systems.

Definition at line 1707 of file equation_systems.C.

References libMesh::EquationSystems::_systems.

Referenced by libMesh::EquationSystems::build_variable_names().

1708 {
1709  unsigned int tot=0;
1710 
1711  for (const auto & pr : _systems)
1712  tot += pr.second->n_vars();
1713 
1714  return tot;
1715 }
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

◆ output()

void Biharmonic::output ( int  timestep,
const Real &  t,
Real &  o_t,
bool  force = false 
)

Definition at line 253 of file biharmonic.C.

References _exio, _o_count, _o_dt, _ofile, _verbose, and libMesh::out.

Referenced by run().

257 {
258  if (!force && t - o_t < _o_dt)
259  return;
260 
261  ++_o_count;
262 
263  if (_verbose)
264  libMesh::out << "Writing state "
265  << timestep
266  << " at time "
267  << t
268  << " to file "
269  << _ofile
270  << "; output a total of "
271  << _o_count
272  << " states so far\n";
273 
274  _exio->write_timestep(_ofile, *this, timestep, t);
275 
276  if (!force)
277  o_t = t;
278 }
Biharmonic::_ofile
std::string _ofile
Definition: biharmonic.h:105
Biharmonic::_exio
std::unique_ptr< ExodusII_IO > _exio
Definition: biharmonic.h:106
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98
Biharmonic::_o_count
int _o_count
Definition: biharmonic.h:108
libMesh::out
OStreamProxy out
Biharmonic::_o_dt
Real _o_dt
Definition: biharmonic.h:107

◆ print_info() [1/2]

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out)
staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

82 {
83  if (_enable_print_counter)
84  out_stream << ReferenceCounter::get_info();
85 }
libMesh::ReferenceCounter::get_info
static std::string get_info()
Gets a string containing the reference information.
Definition: reference_counter.C:47
libMesh::ReferenceCounter::_enable_print_counter
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
Definition: reference_counter.h:143

◆ print_info() [2/2]

void libMesh::EquationSystems::print_info ( std::ostream &  os = libMesh::out) const
inherited

Prints information about the equation systems, by default to libMesh::out.

Definition at line 1690 of file equation_systems.C.

References libMesh::EquationSystems::get_info().

Referenced by assemble_and_solve(), do_compare(), main(), and libMesh::operator<<().

1691 {
1692  os << this->get_info()
1693  << std::endl;
1694 }
libMesh::EquationSystems::get_info
virtual std::string get_info() const
Definition: equation_systems.C:1657

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and TIMPI::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), MeshInputTest::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
TIMPI::Communicator::rank
processor_id_type rank() const
libMesh::ParallelObject::_communicator
const Parallel::Communicator & _communicator
Definition: parallel_object.h:120

◆ read() [1/3]

template<typename InValType >
void libMesh::EquationSystems::read ( std::string_view  name,
const XdrMODE  mode,
const unsigned int  read_flags = (READ_HEADER | READ_DATA),
bool  partition_agnostic = true 
)
inherited

Read & initialize the systems from disk using the XDR data format.

This format allows for machine-independent binary output.

Set which sections of the file to read by bitwise OR'ing the EquationSystems::ReadFlags enumeration together. For example, to read all sections of the file, set read_flags to: (READ_HEADER | READ_DATA | READ_ADDITIONAL_DATA)

Note
The equation system can be defined without initializing the data vectors to any solution values. This can be done by omitting READ_DATA in the read_flags parameter.

If XdrMODE is omitted, it will be inferred as READ for filenames containing .xda or as DECODE for filenames containing .xdr

Parameters
nameName of the file to be read.
read_flagsSingle flag created by bitwise-OR'ing several flags together.
modeControls whether reading is done in binary or ascii mode.
partition_agnosticIf true then the mesh and degrees of freedom will be temporarily renumbered in a partition agnostic way so that files written using "n" mpi processes can be re-read on "m" mpi processes. This renumbering is not compatible with meshes that have two nodes in exactly the same position!

Definition at line 89 of file equation_systems_io.C.

References libMesh::Quality::name(), and libMesh::ParallelObject::processor_id().

Referenced by main(), libMesh::EquationSystems::read(), libMesh::FileHistoryData::retrieve_adjoint_solution(), libMesh::FileHistoryData::retrieve_primal_solution(), and SlitMeshRefinedSystemTest::testRestart().

93 {
94  // This will unzip a file with .bz2 as the extension, otherwise it
95  // simply returns the name if the file need not be unzipped.
96  Xdr io ((this->processor_id() == 0) ? std::string(name) : "", mode);
97 
98  std::function<std::unique_ptr<Xdr>()> local_io_functor;
99  local_io_functor = [this,&name,&mode]() {
100  return std::make_unique<Xdr>(local_file_name(this->processor_id(), name), mode); };
101 
102  this->read(io, local_io_functor, read_flags, partition_agnostic);
103 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::read
void read(std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
Read & initialize the systems from disk using the XDR data format.
Definition: equation_systems_io.C:89
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114

◆ read() [2/3]

template<typename InValType >
void libMesh::EquationSystems::read ( std::string_view  name,
const unsigned int  read_flags = (READ_HEADER | READ_DATA),
bool  partition_agnostic = true 
)
inherited

Definition at line 76 of file equation_systems_io.C.

References libMesh::DECODE, libMesh::Quality::name(), libMesh::READ, and libMesh::EquationSystems::read().

79 {
80  XdrMODE mode = READ;
81  if (name.find(".xdr") != std::string::npos)
82  mode = DECODE;
83  this->read(name, mode, read_flags, partition_agnostic);
84 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::XdrMODE
XdrMODE
Defines an enum for read/write mode in Xdr format.
Definition: enum_xdr_mode.h:35
libMesh::EquationSystems::read
void read(std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
Read & initialize the systems from disk using the XDR data format.
Definition: equation_systems_io.C:89

◆ read() [3/3]

template<typename InValType >
void libMesh::EquationSystems::read ( Xdr &  io,
std::function< std::unique_ptr< Xdr >()> &  local_io_functor,
const unsigned int  read_flags = (READ_HEADER | READ_DATA),
bool  partition_agnostic = true 
)
inherited


This program implements the output of an EquationSystems object. This warrants some documentation. The output file essentially consists of 11 sections: 

1.) A version header (for non-'legacy' formats, libMesh-0.7.0 and greater).
2.) The number of individual equation systems (unsigned int)

for each system

3.)  The name of the system (string)
4.)  The type of the system (string)

handled through System::read():

+-------------------------------------------------------------+
|  5.) The number of variables in the system (unsigned int)   |
|                                                             |
|   for each variable in the system                           |
|                                                             |
|    6.) The name of the variable (string)                    |
|                                                             |
|    7.) Combined in an FEType:                               |
|         - The approximation order(s) of the variable (Order |
|           Enum, cast to int/s)                              |
|         - The finite element family/ies of the variable     |
|           (FEFamily Enum, cast to int/s)                    |
|                                                             |
|   end variable loop                                         |
|                                                             |
| 8.) The number of additional vectors (unsigned int),        |
|                                                             |
|    for each additional vector in the equation system object |
|                                                             |
|    9.) the name of the additional vector  (string)          |
+-------------------------------------------------------------+

end system loop


for each system, handled through System::read_{serialized,parallel}_data():

+--------------------------------------------------------------+
| 10.) The global solution vector, re-ordered to be node-major |
|     (More on this later.)                                    |
|                                                              |
|    for each additional vector in the equation system object  |
|                                                              |
|    11.) The global additional vector, re-ordered to be       |
|         node-major (More on this later.)                     |
+--------------------------------------------------------------+

end system loop

Note that the actual IO is handled through the Xdr class (to be renamed later?) which provides a uniform interface to both the XDR (eXternal Data Representation) interface and standard ASCII output. Thus this one section of code will read XDR or ASCII files with no changes.

Definition at line 108 of file equation_systems_io.C.

References libMesh::EquationSystems::_mesh, libMesh::EquationSystems::add_system(), TIMPI::Communicator::broadcast(), libMesh::MeshRefinement::clean_refinement_flags(), libMesh::Xdr::close(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::MeshBase::fix_broken_node_and_element_numbering(), libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::EquationSystems::init(), libMesh::libmesh_assert(), mesh, libMesh::ParallelObject::processor_id(), libMesh::EquationSystems::read(), libMesh::EquationSystems::READ_ADDITIONAL_DATA, libMesh::EquationSystems::READ_BASIC_ONLY, libMesh::EquationSystems::READ_DATA, libMesh::EquationSystems::READ_HEADER, libMesh::System::read_header(), libMesh::EquationSystems::READ_LEGACY_FORMAT, libMesh::Xdr::reading(), libMesh::System::set_basic_system_only(), libMesh::Xdr::set_version(), libMesh::EquationSystems::TRY_READ_IFEMS, and libMesh::EquationSystems::update().

112 {
176  // Set booleans from the read_flags argument
177  const bool read_header = read_flags & EquationSystems::READ_HEADER;
178  const bool read_data = read_flags & EquationSystems::READ_DATA;
179  const bool read_additional_data = read_flags & EquationSystems::READ_ADDITIONAL_DATA;
180  const bool read_legacy_format = read_flags & EquationSystems::READ_LEGACY_FORMAT;
181  const bool try_read_ifems = read_flags & EquationSystems::TRY_READ_IFEMS;
182  const bool read_basic_only = read_flags & EquationSystems::READ_BASIC_ONLY;
183  bool read_parallel_files = false;
184 
185  std::vector<std::pair<std::string, System *>> xda_systems;
186 
187  libmesh_assert (io.reading());
188 
189  {
190  // 1.)
191  // Read the version header.
192  std::string version = "legacy";
193  if (!read_legacy_format)
194  {
195  if (this->processor_id() == 0) io.data(version);
196  this->comm().broadcast(version);
197 
198  // All processors have the version header, if it does not contain
199  // the libMesh_label string then it is a legacy file.
200  const std::string libMesh_label = "libMesh-";
201  std::string::size_type lm_pos = version.find(libMesh_label);
202  if (lm_pos==std::string::npos)
203  {
204  io.close();
205 
206  // Recursively call this read() function but with the
207  // EquationSystems::READ_LEGACY_FORMAT bit set.
208  this->read (io, local_io_functor, (read_flags | EquationSystems::READ_LEGACY_FORMAT), partition_agnostic);
209  return;
210  }
211 
212  // Figure out the libMesh version that created this file
213  std::istringstream iss(version.substr(lm_pos + libMesh_label.size()));
214  int ver_major = 0, ver_minor = 0, ver_patch = 0;
215  char dot;
216  iss >> ver_major >> dot >> ver_minor >> dot >> ver_patch;
217  io.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
218 
219 
220  read_parallel_files = (version.rfind(" parallel") < version.size());
221 
222  // If requested that we try to read infinite element information,
223  // and the string " with infinite elements" is not in the version,
224  // then tack it on. This is for compatibility reading ifem
225  // files written prior to 11/10/2008 - BSK
226  if (try_read_ifems)
227  if (!(version.rfind(" with infinite elements") < version.size()))
228  version += " with infinite elements";
229 
230  }
231  else
232  libmesh_deprecated();
233 
234  LOG_SCOPE("read()", "EquationSystems");
235 
236  // 2.)
237  // Read the number of equation systems
238  unsigned int n_sys=0;
239  if (this->processor_id() == 0) io.data (n_sys);
240  this->comm().broadcast(n_sys);
241 
242  for (unsigned int sys=0; sys<n_sys; sys++)
243  {
244  // 3.)
245  // Read the name of the sys-th equation system
246  std::string sys_name;
247  if (this->processor_id() == 0) io.data (sys_name);
248  this->comm().broadcast(sys_name);
249 
250  // 4.)
251  // Read the type of the sys-th equation system
252  std::string sys_type;
253  if (this->processor_id() == 0) io.data (sys_type);
254  this->comm().broadcast(sys_type);
255 
256  if (read_header)
257  this->add_system (sys_type, sys_name);
258 
259  // 5.) - 9.)
260  // Let System::read_header() do the job
261  System & new_system = this->get_system(sys_name);
262  new_system.read_header (io,
263  version,
264  read_header,
265  read_additional_data,
266  read_legacy_format);
267 
268  xda_systems.emplace_back(sys_name, &new_system);
269 
270  // If we're only creating "basic" systems, we need to tell
271  // each system that before we call init() later.
272  if (read_basic_only)
273  new_system.set_basic_system_only();
274  }
275  }
276 
277 
278 
279  // Now we are ready to initialize the underlying data
280  // structures. This will initialize the vectors for
281  // storage, the dof_map, etc...
282  if (read_header)
283  this->init();
284 
285  // 10.) & 11.)
286  // Read and set the numeric vector values
287  if (read_data)
288  {
289  std::unique_ptr<Xdr> local_io;
290 
291  // the EquationSystems::read() method should look constant from the mesh
292  // perspective, but we need to assign a temporary numbering to the nodes
293  // and elements in the mesh, which requires that we abuse const_cast
294  if (!read_legacy_format && partition_agnostic)
295  {
296  MeshBase & mesh = const_cast<MeshBase &>(this->get_mesh());
297  MeshTools::Private::globally_renumber_nodes_and_elements(mesh);
298  }
299 
300  for (auto & pr : xda_systems)
301  if (read_legacy_format)
302  {
303  libmesh_deprecated();
304 #ifdef LIBMESH_ENABLE_DEPRECATED
305  pr.second->read_legacy_data (io, read_additional_data);
306 #endif
307  }
308  else
309  if (read_parallel_files)
310  {
311  if (!local_io)
312  {
313  local_io = local_io_functor();
314  libmesh_assert(local_io->reading());
315  }
316  pr.second->read_parallel_data<InValType> (*local_io, read_additional_data);
317  }
318  else
319  pr.second->read_serialized_data<InValType> (io, read_additional_data);
320 
321 
322  // Undo the temporary numbering.
323  if (!read_legacy_format && partition_agnostic)
324  _mesh.fix_broken_node_and_element_numbering();
325  }
326 
327  // Localize each system's data
328  this->update();
329 
330  #ifdef LIBMESH_ENABLE_AMR
331  MeshRefinement mesh_refine(_mesh);
332  mesh_refine.clean_refinement_flags();
333  #endif
334 }
mesh
MeshBase & mesh
Definition: mesh_communication.C:1476
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition: parallel_object.h:97
libMesh::MeshBase::fix_broken_node_and_element_numbering
virtual void fix_broken_node_and_element_numbering()=0
There is no reason for a user to ever call this function.
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::EquationSystems::read
void read(std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
Read & initialize the systems from disk using the XDR data format.
Definition: equation_systems_io.C:89
libMesh::MeshTools::Private::globally_renumber_nodes_and_elements
void globally_renumber_nodes_and_elements(MeshBase &)
There is no reason for a user to ever call this function.
Definition: mesh_tools.C:2542
TIMPI::Communicator::broadcast
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
libMesh::EquationSystems::get_mesh
const MeshBase & get_mesh() const
Definition: equation_systems.h:646
libMesh::EquationSystems::init
virtual void init()
Initialize all the systems.
Definition: equation_systems.C:80
libMesh::EquationSystems::add_system
virtual System & add_system(std::string_view system_type, std::string_view name)
Add the system of type system_type named name to the systems array.
Definition: equation_systems.C:338
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114
libMesh::EquationSystems::update
void update()
Updates local values for all the systems.
Definition: equation_systems.C:327

◆ redundant_added_side()

bool libMesh::EquationSystems::redundant_added_side ( const Elem &  elem,
unsigned int  side 
)
staticinherited

Definition at line 1577 of file equation_systems.C.

References libMesh::Elem::active(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::Elem::neighbor_ptr(), and libMesh::remote_elem.

Referenced by libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), and libMesh::ExodusII_IO::write_nodal_data().

1578 {
1579  libmesh_assert(elem.active());
1580 
1581  const Elem * neigh = elem.neighbor_ptr(side);
1582 
1583  // Write boundary sides.
1584  if (!neigh)
1585  return false;
1586 
1587  // Write ghost sides in Nemesis
1588  if (neigh == remote_elem)
1589  return false;
1590 
1591  // Don't write a coarser side if a finer side exists
1592  if (!neigh->active())
1593  return true;
1594 
1595  // Don't write a side redundantly from both of the
1596  // elements sharing it. We'll disambiguate with id().
1597  return (neigh->id() < elem.id());
1598 }
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::remote_elem
const RemoteElem * remote_elem
Definition: remote_elem.C:57

◆ refine_in_reinit_flag()

bool libMesh::EquationSystems::refine_in_reinit_flag ( )
inlineinherited
Returns
Whether or not calls to reinit() will try to coarsen/refine the mesh

Definition at line 579 of file equation_systems.h.

References libMesh::EquationSystems::_refine_in_reinit.

579 { return this->_refine_in_reinit; }
libMesh::EquationSystems::_refine_in_reinit
bool _refine_in_reinit
Flag for whether to call coarsen/refine in reinit().
Definition: equation_systems.h:617

◆ reinit()

void libMesh::EquationSystems::reinit ( )
virtualinherited

Handle any mesh changes and reinitialize all the systems on the updated mesh.

Definition at line 92 of file equation_systems.C.

References libMesh::EquationSystems::reinit_solutions(), and libMesh::EquationSystems::reinit_systems().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), assemble_and_solve(), libMesh::AdjointRefinementEstimator::estimate_error(), main(), run_timestepping(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), EquationSystemsTest::testBadVarNames(), MeshAssignTest::testMeshMoveAssign(), EquationSystemsTest::testPostInitAddElem(), EquationSystemsTest::testPostInitAddRealSystem(), EquationSystemsTest::testPostInitAddSystem(), SystemsTest::testProjectCube(), SystemsTest::testProjectLine(), SystemsTest::testProjectSquare(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testReinitWithNodeElem(), EquationSystemsTest::testRepartitionThenReinit(), and EquationSystemsTest::testSelectivePRefine().

93 {
94  const bool mesh_changed = this->reinit_solutions();
95 
96  // If the mesh has changed, systems will need to reinitialize their
97  // own data on the new mesh.
98  if (mesh_changed)
99  this->reinit_systems();
100 }
libMesh::EquationSystems::reinit_solutions
bool reinit_solutions()
Handle any mesh changes and project any solutions onto the updated mesh.
Definition: equation_systems.C:131
libMesh::EquationSystems::reinit_systems
virtual void reinit_systems()
Reinitialize all systems on the current mesh.
Definition: equation_systems.C:257

◆ reinit_mesh()

void libMesh::EquationSystems::reinit_mesh ( )
virtualinherited

Handle the association of a completely new mesh with the EquationSystem and all the Systems assigned to it.

Definition at line 102 of file equation_systems.C.

References libMesh::EquationSystems::_mesh, libMesh::MeshRefinement::clean_refinement_flags(), libMesh::EquationSystems::get_system(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

Referenced by libMesh::EquationSystems::init(), and MeshAssignTest::testMeshMoveAssign().

103 {
104  const unsigned int n_sys = this->n_systems();
105 
106  libmesh_assert_not_equal_to (n_sys, 0);
107 
108  // Tell all the \p DofObject entities how many systems
109  // there are.
110  for (auto & node : _mesh.node_ptr_range())
111  node->set_n_systems(n_sys);
112 
113  for (auto & elem : _mesh.element_ptr_range())
114  elem->set_n_systems(n_sys);
115 
116  //for (auto i : make_range(this->n_systems()))
117  //this->get_system(i).init();
118 
119 #ifdef LIBMESH_ENABLE_AMR
120  MeshRefinement mesh_refine(_mesh);
121  mesh_refine.clean_refinement_flags();
122 #endif
123 
124  // Now loop over all the systems belonging to this ES
125  // and call reinit_mesh for each system
126  for (auto i : make_range(this->n_systems()))
127  this->get_system(i).reinit_mesh();
128 
129 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ reinit_solutions()

bool libMesh::EquationSystems::reinit_solutions ( )
inherited

Handle any mesh changes and project any solutions onto the updated mesh.

Returns
Whether or not the mesh may have changed.

Definition at line 131 of file equation_systems.C.

References libMesh::EquationSystems::_mesh, libMesh::EquationSystems::_refine_in_reinit, libMesh::MeshRefinement::coarsen_elements(), libMesh::MeshBase::contract(), libMesh::DofMap::distribute_dofs(), libMesh::MeshRefinement::face_level_mismatch_limit(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::make_range(), libMesh::EquationSystems::n_systems(), libMesh::MeshRefinement::overrefined_boundary_limit(), libMesh::System::prolong_vectors(), libMesh::MeshRefinement::refine_elements(), libMesh::System::reinit_constraints(), libMesh::System::restrict_vectors(), and libMesh::MeshRefinement::underrefined_boundary_limit().

Referenced by libMesh::EquationSystems::reinit().

132 {
133  parallel_object_only();
134 
135  const unsigned int n_sys = this->n_systems();
136  libmesh_assert_not_equal_to (n_sys, 0);
137 
138  // And any new systems will need initialization
139  for (unsigned int i=0; i != n_sys; ++i)
140  if (!this->get_system(i).is_initialized())
141  this->get_system(i).init();
142 
143  // We used to assert that all nodes and elements *already* had
144  // n_systems() properly set; however this is false in the case where
145  // user code has manually added nodes and/or elements to an
146  // already-initialized system.
147 
148  // Make sure all the \p DofObject entities know how many systems
149  // there are.
150  {
151  // All the nodes
152  for (auto & node : _mesh.node_ptr_range())
153  node->set_n_systems(n_sys);
154 
155  // All the elements
156  for (auto & elem : _mesh.element_ptr_range())
157  elem->set_n_systems(n_sys);
158  }
159 
160  // Localize each system's vectors
161  for (unsigned int i=0; i != n_sys; ++i)
162  this->get_system(i).re_update();
163 
164 #ifdef LIBMESH_ENABLE_AMR
165 
166  bool mesh_changed = false;
167 
168  // FIXME: For backwards compatibility, assume
169  // refine_and_coarsen_elements or refine_uniformly have already
170  // been called
171  {
172  for (unsigned int i=0; i != n_sys; ++i)
173  {
174  System & sys = this->get_system(i);
175 
176  // Even if the system doesn't have any variables in it we want
177  // consistent behavior; e.g. distribute_dofs should have the
178  // opportunity to count up zero dofs on each processor.
179  //
180  // Who's been adding zero-var systems anyway, outside of my
181  // unit tests? - RHS
182  // if (!sys.n_vars())
183  // continue;
184 
185  sys.get_dof_map().distribute_dofs(_mesh);
186 
187  // Recreate any user or internal constraints
188  sys.reinit_constraints();
189 
190  // Even if there weren't any constraint changes,
191  // reinit_constraints() did prepare_send_list() for us.
192 
193  sys.prolong_vectors();
194  }
195  mesh_changed = true;
196  }
197 
198  if (this->_refine_in_reinit)
199  {
200  // Don't override any user refinement settings
201  MeshRefinement mesh_refine(_mesh);
202  mesh_refine.face_level_mismatch_limit() = 0; // unlimited
203  mesh_refine.overrefined_boundary_limit() = -1; // unlimited
204  mesh_refine.underrefined_boundary_limit() = -1; // unlimited
205 
206  // Try to coarsen the mesh, then restrict each system's vectors
207  // if necessary
208  if (mesh_refine.coarsen_elements())
209  {
210  for (auto i : make_range(this->n_systems()))
211  {
212  System & sys = this->get_system(i);
213  sys.get_dof_map().distribute_dofs(_mesh);
214  sys.reinit_constraints();
215 
216  // Even if there weren't any constraint changes,
217  // reinit_constraints() did prepare_send_list() for us.
218 
219  sys.restrict_vectors();
220  }
221  mesh_changed = true;
222  }
223 
224  // Once vectors are all restricted, we can delete
225  // children of coarsened elements
226  if (mesh_changed)
227  this->get_mesh().contract();
228 
229  // Try to refine the mesh, then prolong each system's vectors
230  // if necessary
231  if (mesh_refine.refine_elements())
232  {
233  for (auto i : make_range(this->n_systems()))
234  {
235  System & sys = this->get_system(i);
236  sys.get_dof_map().distribute_dofs(_mesh);
237  sys.reinit_constraints();
238 
239  // Even if there weren't any constraint changes,
240  // reinit_constraints() did prepare_send_list() for us.
241 
242  sys.prolong_vectors();
243  }
244  mesh_changed = true;
245  }
246  }
247 
248  return mesh_changed;
249 
250 #endif // #ifdef LIBMESH_ENABLE_AMR
251 
252  return false;
253 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::EquationSystems::_refine_in_reinit
bool _refine_in_reinit
Flag for whether to call coarsen/refine in reinit().
Definition: equation_systems.h:617
libMesh::MeshBase::contract
virtual bool contract()=0
Delete subactive (i.e.
libMesh::EquationSystems::get_mesh
const MeshBase & get_mesh() const
Definition: equation_systems.h:646
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ reinit_systems()

void libMesh::EquationSystems::reinit_systems ( )
virtualinherited

Reinitialize all systems on the current mesh.

Definition at line 257 of file equation_systems.C.

References libMesh::EquationSystems::get_system(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

Referenced by libMesh::EquationSystems::reinit().

258 {
259  for (auto i : make_range(this->n_systems()))
260  this->get_system(i).reinit();
261 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ run()

void Biharmonic::run ( )

Definition at line 289 of file biharmonic.C.

References _dt, _t0, _t1, _verbose, libMesh::out, output(), libMesh::Real, and step().

290 {
291  Real t = _t0, o_t = 0.0;
292  int timestep = 1;
293 
294  // Force-write the initial timestep
295  output(timestep, t, o_t, true);
296 
297  while (t < _t1)
298  {
299  ++timestep;
300 
301  // A pretty update message
302  if (_verbose)
303  libMesh::out << "Solving for state " << timestep << ", time " << t << "\n";
304 
305  // Move biharmonic one timestep forward
306  step();
307 
308  // Keep track of time and timestep
309  t += _dt;
310 
311  // Output
312  output(timestep, t, o_t);
313  } // while(t < _t1)
314 
315  // Force-write the final timestep
316  output(timestep, t, o_t, true);
317 }
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98
Biharmonic::output
void output(int timestep, const Real &t, Real &o_t, bool force=false)
Definition: biharmonic.C:253
Biharmonic::step
void step(const Real &dt=-1.0)
Definition: biharmonic.C:232
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:144
libMesh::out
OStreamProxy out

◆ sensitivity_solve()

void libMesh::EquationSystems::sensitivity_solve ( const ParameterVector &  parameters)
virtualinherited

Call sensitivity_solve on all the individual equation systems.

By default this function solves each sensitivity system once, in the order in which in which they were added. For more sophisticated decoupled problems the user may with to override this behavior in a derived class.

Definition at line 430 of file equation_systems.C.

References libMesh::EquationSystems::get_system(), libMesh::libmesh_assert(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

431 {
432  libmesh_assert (this->n_systems());
433 
434  for (auto i : make_range(this->n_systems()))
435  this->get_system(i).sensitivity_solve(parameters_in);
436 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ solve()

void libMesh::EquationSystems::solve ( )
virtualinherited

Call solve on all the individual equation systems.

By default this function solves each equation system once, in the order they were added. For more sophisticated decoupled problems the user may with to override this behavior in a derived class.

Definition at line 420 of file equation_systems.C.

References libMesh::EquationSystems::get_system(), libMesh::libmesh_assert(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error().

421 {
422  libmesh_assert (this->n_systems());
423 
424  for (auto i : make_range(this->n_systems()))
425  this->get_system(i).solve();
426 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ step()

void Biharmonic::step ( const Real &  dt = -1.0)

Definition at line 232 of file biharmonic.C.

References _dt, _dt0, and _jr.

Referenced by run().

233 {
234  // We need to update the old solution vector.
235  // The old solution vector will be the current solution vector from the
236  // previous time step. We use vector assignment. Only TransientSystems
237  // (and systems derived from them) contain old solutions.
238  if (dt_in < 0)
239  _dt = _dt0;
240  else
241  _dt = dt_in;
242 
243  *(_jr->old_local_solution) = *(_jr->current_local_solution);
244 
245  // this will localize the current solution, resulting in a
246  // current_local_solution with correct ghost values
247  _jr->solve();
248 }

◆ update()

void libMesh::EquationSystems::update ( )
inherited

Updates local values for all the systems.

Definition at line 327 of file equation_systems.C.

References libMesh::EquationSystems::get_system(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

Referenced by main(), and libMesh::EquationSystems::read().

328 {
329  LOG_SCOPE("update()", "EquationSystems");
330 
331  // Localize each system's vectors
332  for (auto i : make_range(this->n_systems()))
333  this->get_system(i).update();
334 }
libMesh::EquationSystems::n_systems
unsigned int n_systems() const
Definition: equation_systems.h:661
libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition: equation_systems.h:757
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition: int_range.h:140

◆ verbose()

bool Biharmonic::verbose ( )
inline

Definition at line 79 of file biharmonic.h.

References _verbose.

79 { return _verbose; }
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98

◆ viewParameters()

void Biharmonic::viewParameters ( )

Definition at line 165 of file biharmonic.C.

References _cahn_hillard, _cnWeight, _degenerate, _dim, _dt0, _energy, _growth, _initialCenter, _initialState, _initialWidth, _kappa, _log_truncation, _N, _netforce, _o_dt, _ofile_base, _T, _t0, _t1, _theta, _theta_c, _tol, _verbose, BALL, int, libMesh::out, ROD, and STRIP.

166 {
167  libMesh::out << "Biharmonic parameters:\n";
168 
169  // Print verbosity status
170  if (_verbose)
171  libMesh::out << "verbose mode is on\n";
172  else
173  libMesh::out << "verbose mode is off\n";
174 
175  // Print parameters
176  libMesh::out << "mesh dimension = " << _dim << "\n";
177  libMesh::out << "initial linear mesh size = " << _N << "\n";
178  libMesh::out << "kappa = " << _kappa << "\n";
179  libMesh::out << "growth = " << (int)_growth << "\n";
180  libMesh::out << "degenerate = " << (int)_degenerate << "\n";
181  libMesh::out << "Cahn-Hillard = " << (int)_cahn_hillard << "\n";
182  libMesh::out << "netforce = " << (int)_netforce << "\n";
183  libMesh::out << "energy = " << _energy << "\n";
184  libMesh::out << "tol = " << _tol << "\n";
185  libMesh::out << "theta = " << _theta << "\n";
186  libMesh::out << "theta_c = " << _theta_c << "\n";
187  libMesh::out << "log truncation = " << _log_truncation << "\n";
188  libMesh::out << "initial timestep size = " << _dt0 << "\n";
189 
190  if (_initialState == STRIP)
191  libMesh::out << "initial state: strip\n";
192 
193  if (_initialState == ROD)
194  libMesh::out << "initial state: rod\n";
195 
196  if (_initialState == BALL)
197  libMesh::out << "initial state: ball\n";
198 
199  libMesh::out << "initial state center = " << _initialCenter(0) << "\n";
200  libMesh::out << "initial state width = " << _initialWidth << "\n";
201  libMesh::out << "initial time (min_time) = " << _t0 << "\n";
202  libMesh::out << "integration time = " << _T << "\n";
203  libMesh::out << "final time (max_time) = " << _t1 << "\n";
204  libMesh::out << "Crank-Nicholson weight = " << _cnWeight << "\n";
205  libMesh::out << "Output timestep = " << _o_dt << "\n";
206  libMesh::out << "Output filename base: " << _ofile_base << "\n";
207 }
Biharmonic::_verbose
bool _verbose
Definition: biharmonic.h:98
Biharmonic::_cnWeight
Real _cnWeight
Definition: biharmonic.h:103
Biharmonic::_kappa
Real _kappa
Definition: biharmonic.h:93
Biharmonic::_theta_c
Real _theta_c
Definition: biharmonic.h:93
Biharmonic::_initialCenter
Point _initialCenter
Definition: biharmonic.h:100
Biharmonic::_tol
Real _tol
Definition: biharmonic.h:94
Biharmonic::_netforce
bool _netforce
Definition: biharmonic.h:95
Biharmonic::_cahn_hillard
bool _cahn_hillard
Definition: biharmonic.h:95
Biharmonic::_energy
FreeEnergyEnum _energy
Definition: biharmonic.h:96
Biharmonic::_log_truncation
int _log_truncation
Definition: biharmonic.h:97
Biharmonic::_dim
unsigned int _dim
Definition: biharmonic.h:92
Biharmonic::_initialWidth
Real _initialWidth
Definition: biharmonic.h:101
libMesh::out
OStreamProxy out
Biharmonic::_growth
bool _growth
Definition: biharmonic.h:95
Biharmonic::_o_dt
Real _o_dt
Definition: biharmonic.h:107
Biharmonic::_N
unsigned int _N
Definition: biharmonic.h:92
Biharmonic::_ofile_base
std::string _ofile_base
Definition: biharmonic.h:105
Biharmonic::_initialState
InitialStateEnum _initialState
Definition: biharmonic.h:99
int
void ErrorVector unsigned int
Definition: adjoints_ex3.C:360
Biharmonic::_theta
Real _theta
Definition: biharmonic.h:93
Biharmonic::_degenerate
bool _degenerate
Definition: biharmonic.h:95

◆ write() [1/4]

void libMesh::EquationSystems::write ( std::string_view  name,
const XdrMODE  mode,
const unsigned int  write_flags = (WRITE_DATA),
bool  partition_agnostic = true 
) const
inherited

Write the systems to disk using the XDR data format.

This format allows for machine-independent binary output.

Set the writing properties using the EquationSystems::WriteFlags enumeration. Set which sections to write out by bitwise OR'ing the enumeration values. Write everything by setting write_flags to: (WRITE_DATA | WRITE_ADDITIONAL_DATA)

Note
The solution data can be omitted by calling this routine with WRITE_DATA omitted in the write_flags argument.

If XdrMODE is omitted, it will be inferred as WRITE for filenames containing .xda or as ENCODE for filenames containing .xdr

Parameters
nameName of the file to be read.
write_flagsSingle flag created by bitwise-OR'ing several flags together.
modeControls whether reading is done in binary or ascii mode.
partition_agnosticIf true then the mesh and degrees of freedom will be temporarily renumbered in a partition agnostic way so that files written using "n" mpi processes can be re-read on "m" mpi processes. This renumbering is not compatible with meshes that have two nodes in exactly the same position!

Definition at line 350 of file equation_systems_io.C.

References libMesh::Quality::name(), libMesh::ParallelObject::processor_id(), libMesh::EquationSystems::WRITE_DATA, and libMesh::EquationSystems::WRITE_PARALLEL_FILES.

Referenced by main(), libMesh::ErrorVector::plot_error(), libMesh::FileHistoryData::rewrite_stored_solution(), libMesh::FileHistoryData::store_adjoint_solution(), libMesh::FileHistoryData::store_initial_solution(), libMesh::FileHistoryData::store_primal_solution(), libMesh::EquationSystems::write(), libMesh::NameBasedIO::write_equation_systems(), and write_output().

354 {
355  Xdr io((this->processor_id()==0) ? std::string(name) : "", mode);
356 
357  std::unique_ptr<Xdr> local_io;
358  // open a parallel buffer if warranted
359  if (write_flags & EquationSystems::WRITE_PARALLEL_FILES && write_flags & EquationSystems::WRITE_DATA)
360  local_io = std::make_unique<Xdr>(local_file_name(this->processor_id(),name), mode);
361 
362  this->write(io, write_flags, partition_agnostic, local_io.get());
363 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::write
void write(std::string_view name, const XdrMODE, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
Write the systems to disk using the XDR data format.
Definition: equation_systems_io.C:350
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114

◆ write() [2/4]

void libMesh::EquationSystems::write ( std::string_view  name,
const unsigned int  write_flags = (WRITE_DATA),
bool  partition_agnostic = true 
) const
inherited

Definition at line 338 of file equation_systems_io.C.

References libMesh::ENCODE, libMesh::Quality::name(), libMesh::WRITE, and libMesh::EquationSystems::write().

341 {
342  XdrMODE mode = WRITE;
343  if (name.find(".xdr") != std::string::npos)
344  mode = ENCODE;
345  this->write(name, mode, write_flags, partition_agnostic);
346 }
libMesh::Quality::name
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
libMesh::EquationSystems::write
void write(std::string_view name, const XdrMODE, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
Write the systems to disk using the XDR data format.
Definition: equation_systems_io.C:350
libMesh::XdrMODE
XdrMODE
Defines an enum for read/write mode in Xdr format.
Definition: enum_xdr_mode.h:35

◆ write() [3/4]

void libMesh::EquationSystems::write ( std::ostream  name,
const unsigned int  write_flags = (WRITE_DATA),
bool  partition_agnostic = true 
) const
inherited

◆ write() [4/4]

void libMesh::EquationSystems::write ( Xdr &  io,
const unsigned int  write_flags = (WRITE_DATA),
bool  partition_agnostic = true,
Xdr *const  local_io = nullptr 
) const
inherited


This program implements the output of an EquationSystems object. This warrants some documentation. The output file essentially consists of 11 sections: 

1.) The version header.
2.) The number of individual equation systems (unsigned int)

for each system

3.)  The name of the system (string)
4.)  The type of the system (string)

handled through System::read():

+-------------------------------------------------------------+
|  5.) The number of variables in the system (unsigned int)   |
|                                                             |
|   for each variable in the system                           |
|                                                             |
|    6.) The name of the variable (string)                    |
|                                                             |
|    7.) Combined in an FEType:                               |
|         - The approximation order(s) of the variable (Order |
|           Enum, cast to int/s)                              |
|         - The finite element family/ies of the variable     |
|           (FEFamily Enum, cast to int/s)                    |
|                                                             |
|   end variable loop                                         |
|                                                             |
| 8.) The number of additional vectors (unsigned int),        |
|                                                             |
|    for each additional vector in the equation system object |
|                                                             |
|    9.) the name of the additional vector  (string)          |
+-------------------------------------------------------------+

end system loop


for each system, handled through System::write_{serialized,parallel}_data():

+--------------------------------------------------------------+
| 10.) The global solution vector, re-ordered to be node-major |
|     (More on this later.)                                    |
|                                                              |
|    for each additional vector in the equation system object  |
|                                                              |
|    11.) The global additional vector, re-ordered to be       |
|         node-major (More on this later.)                     |
+--------------------------------------------------------------+

end system loop

Note that the actual IO is handled through the Xdr class (to be renamed later?) which provides a uniform interface to both the XDR (eXternal Data Representation) interface and standard ASCII output. Thus this one section of code will write XDR or ASCII files with no changes.

Definition at line 367 of file equation_systems_io.C.

References libMesh::EquationSystems::_mesh, libMesh::EquationSystems::_systems, libMesh::Xdr::close(), libMesh::Xdr::data(), libMesh::get_io_compatibility_version(), libMesh::EquationSystems::get_mesh(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), libMesh::libmesh_assert(), mesh, libMesh::ParallelObject::processor_id(), libMesh::Xdr::set_version(), libMesh::EquationSystems::WRITE_ADDITIONAL_DATA, libMesh::EquationSystems::WRITE_DATA, libMesh::EquationSystems::WRITE_PARALLEL_FILES, and libMesh::Xdr::writing().

371 {
435  // the EquationSystems::write() method should look constant,
436  // but we need to assign a temporary numbering to the nodes
437  // and elements in the mesh, which requires that we abuse const_cast
438  if (partition_agnostic)
439  {
440  MeshBase & mesh = const_cast<MeshBase &>(this->get_mesh());
441  MeshTools::Private::globally_renumber_nodes_and_elements(mesh);
442  }
443 
444  // set booleans from write_flags argument
445  const bool write_data = write_flags & EquationSystems::WRITE_DATA;
446  const bool write_additional_data = write_flags & EquationSystems::WRITE_ADDITIONAL_DATA;
447 
448  // always write parallel files if we're instructed to write in
449  // parallel
450  const bool write_parallel_files =
451  (write_flags & EquationSystems::WRITE_PARALLEL_FILES)
452  // Even if we're on a distributed mesh, we may or may not have a
453  // consistent way of reconstructing the same mesh partitioning
454  // later, but we need the same mesh partitioning if we want to
455  // reread the parallel solution safely, so let's write a serial file
456  // unless specifically requested not to.
457  // ||
458  // // but also write parallel files if we haven't been instructed to
459  // // write in serial and we're on a distributed mesh
460  // (!(write_flags & EquationSystems::WRITE_SERIAL_FILES) &&
461  // !this->get_mesh().is_serial())
462  ;
463 
464  if (write_parallel_files && write_data)
465  libmesh_assert(local_io);
466 
467  {
468  libmesh_assert (io.writing());
469 
470  LOG_SCOPE("write()", "EquationSystems");
471 
472  const unsigned int proc_id = this->processor_id();
473 
474  unsigned int n_sys = 0;
475  for (auto & pr : _systems)
476  if (!pr.second->hide_output())
477  n_sys++;
478 
479  // set the version number in the Xdr object
480  io.set_version(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION,
481  LIBMESH_MINOR_VERSION,
482  LIBMESH_MICRO_VERSION));
483 
484  // Only write the header information
485  // if we are processor 0.
486  if (proc_id == 0)
487  {
488  std::string comment;
489 
490  // 1.)
491  // Write the version header
492  std::string version("libMesh-" + libMesh::get_io_compatibility_version());
493  if (write_parallel_files) version += " parallel";
494 
495 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
496  version += " with infinite elements";
497 #endif
498  io.data (version, "# File Format Identifier");
499 
500  // 2.)
501  // Write the number of equation systems
502  io.data (n_sys, "# No. of Equation Systems");
503 
504  for (auto & [sys_name, sys] : _systems)
505  {
506  // Ignore this system if it has been marked as hidden
507  if (sys->hide_output()) continue;
508 
509  // 3.)
510  // Write the name of the sys_num-th system
511  {
512  const unsigned int sys_num = sys->number();
513 
514  comment = "# Name, System No. ";
515  comment += std::to_string(sys_num);
516 
517  // Note: There is no Xdr::data overload taking a "const
518  // std::string &" so we need to make a copy.
519  std::string copy = sys_name;
520  io.data (copy, comment);
521  }
522 
523  // 4.)
524  // Write the type of system handled
525  {
526  const unsigned int sys_num = sys->number();
527  std::string sys_type = sys->system_type();
528 
529  comment = "# Type, System No. ";
530  comment += std::to_string(sys_num);
531 
532  io.data (sys_type, comment);
533  }
534 
535  // 5.) - 9.)
536  // Let System::write_header() do the job
537  sys->write_header (io, version, write_additional_data);
538  }
539  }
540 
541  // Start from the first system, again,
542  // to write vectors to disk, if wanted
543  if (write_data)
544  {
545  for (auto & pr : _systems)
546  {
547  // Ignore this system if it has been marked as hidden
548  if (pr.second->hide_output()) continue;
549 
550  // 10.) + 11.)
551  if (write_parallel_files)
552  pr.second->write_parallel_data (*local_io,write_additional_data);
553  else
554  pr.second->write_serialized_data (io,write_additional_data);
555  }
556 
557  if (local_io)
558  local_io->close();
559  }
560 
561  io.close();
562  }
563 
564  // the EquationSystems::write() method should look constant,
565  // but we need to undo the temporary numbering of the nodes
566  // and elements in the mesh, which requires that we abuse const_cast
567  if (partition_agnostic)
568  const_cast<MeshBase &>(_mesh).fix_broken_node_and_element_numbering();
569 }
mesh
MeshBase & mesh
Definition: mesh_communication.C:1476
libMesh::EquationSystems::_mesh
MeshBase & _mesh
The mesh data structure.
Definition: equation_systems.h:606
libMesh::get_io_compatibility_version
std::string get_io_compatibility_version()
Specifier for I/O file compatibility features.
Definition: libmesh_version.C:80
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::MeshTools::Private::globally_renumber_nodes_and_elements
void globally_renumber_nodes_and_elements(MeshBase &)
There is no reason for a user to ever call this function.
Definition: mesh_tools.C:2542
libMesh::EquationSystems::get_mesh
const MeshBase & get_mesh() const
Definition: equation_systems.h:646
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition: parallel_object.h:114
libMesh::EquationSystems::_systems
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
Definition: equation_systems.h:611

Friends And Related Function Documentation

◆ JR

friend class JR
friend

Definition at line 110 of file biharmonic.h.

Member Data Documentation

◆ _cahn_hillard

bool Biharmonic::_cahn_hillard
private

Definition at line 95 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _cnWeight

Real Biharmonic::_cnWeight
private

Definition at line 103 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), and libMesh::StaticCondensationDofMap::reinit().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

◆ _degenerate

bool Biharmonic::_degenerate
private

Definition at line 95 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _dim

unsigned int Biharmonic::_dim
private

Definition at line 92 of file biharmonic.h.

Referenced by Biharmonic(), Biharmonic::JR::JR(), and viewParameters().

◆ _dt

Real Biharmonic::_dt
private

Definition at line 102 of file biharmonic.h.

Referenced by dt(), init(), run(), and step().

◆ _dt0

Real Biharmonic::_dt0
private

Definition at line 102 of file biharmonic.h.

Referenced by Biharmonic(), dt0(), step(), and viewParameters().

◆ _enable_default_ghosting

bool libMesh::EquationSystems::_enable_default_ghosting
protectedinherited

Flag for whether to enable default ghosting on newly added Systems.

Default value: true

Definition at line 623 of file equation_systems.h.

Referenced by libMesh::EquationSystems::add_system(), and libMesh::EquationSystems::enable_default_ghosting().

◆ _enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

◆ _energy

FreeEnergyEnum Biharmonic::_energy
private

Definition at line 96 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _exio

std::unique_ptr<ExodusII_IO> Biharmonic::_exio
private

Definition at line 106 of file biharmonic.h.

Referenced by Biharmonic(), and output().

◆ _growth

bool Biharmonic::_growth
private

Definition at line 95 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _initialCenter

Point Biharmonic::_initialCenter
private

Definition at line 100 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _initialState

InitialStateEnum Biharmonic::_initialState
private

Definition at line 99 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _initialWidth

Real Biharmonic::_initialWidth
private

Definition at line 101 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _jr

JR* Biharmonic::_jr
private

Definition at line 113 of file biharmonic.h.

Referenced by init(), and step().

◆ _kappa

Real Biharmonic::_kappa
private

Definition at line 93 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _log_truncation

int Biharmonic::_log_truncation
private

Definition at line 97 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _mesh

ReplicatedMesh& Biharmonic::_mesh
private

Definition at line 111 of file biharmonic.h.

Referenced by Biharmonic().

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

◆ _N

unsigned int Biharmonic::_N
private

Definition at line 92 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects
staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _netforce

bool Biharmonic::_netforce
private

Definition at line 95 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _o_count

int Biharmonic::_o_count
private

Definition at line 108 of file biharmonic.h.

Referenced by init(), and output().

◆ _o_dt

Real Biharmonic::_o_dt
private

Definition at line 107 of file biharmonic.h.

Referenced by Biharmonic(), output(), and viewParameters().

◆ _ofile

std::string Biharmonic::_ofile
private

Definition at line 105 of file biharmonic.h.

Referenced by Biharmonic(), and output().

◆ _ofile_base

std::string Biharmonic::_ofile_base
private

Definition at line 105 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _refine_in_reinit

bool libMesh::EquationSystems::_refine_in_reinit
protectedinherited

Flag for whether to call coarsen/refine in reinit().

Default value: true

Definition at line 617 of file equation_systems.h.

Referenced by libMesh::EquationSystems::disable_refine_in_reinit(), libMesh::EquationSystems::enable_refine_in_reinit(), libMesh::EquationSystems::refine_in_reinit_flag(), and libMesh::EquationSystems::reinit_solutions().

◆ _systems

std::map<std::string, std::unique_ptr<System>, std::less<> > libMesh::EquationSystems::_systems
protectedinherited

Data structure holding the systems.

Definition at line 611 of file equation_systems.h.

Referenced by libMesh::EquationSystems::add_system(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::clear(), libMesh::EquationSystems::compare(), libMesh::EquationSystems::get_info(), libMesh::EquationSystems::get_system(), libMesh::EquationSystems::get_vars_active_subdomains(), libMesh::EquationSystems::has_system(), libMesh::EquationSystems::n_active_dofs(), libMesh::EquationSystems::n_dofs(), libMesh::EquationSystems::n_systems(), libMesh::EquationSystems::n_vars(), and libMesh::EquationSystems::write().

◆ _T

Real Biharmonic::_T
private

Definition at line 102 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _t0

Real Biharmonic::_t0
private

Definition at line 102 of file biharmonic.h.

Referenced by Biharmonic(), run(), and viewParameters().

◆ _t1

Real Biharmonic::_t1
private

Definition at line 102 of file biharmonic.h.

Referenced by Biharmonic(), run(), and viewParameters().

◆ _theta

Real Biharmonic::_theta
private

Definition at line 93 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _theta_c

Real Biharmonic::_theta_c
private

Definition at line 93 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _tol

Real Biharmonic::_tol
private

Definition at line 94 of file biharmonic.h.

Referenced by Biharmonic(), and viewParameters().

◆ _verbose

bool Biharmonic::_verbose
private

Definition at line 98 of file biharmonic.h.

Referenced by Biharmonic(), init(), output(), run(), verbose(), and viewParameters().

◆ parameters

Parameters libMesh::EquationSystems::parameters
inherited

Data structure holding arbitrary parameters.

Definition at line 597 of file equation_systems.h.

Referenced by add_M_C_K_helmholtz(), assemble_biharmonic(), assemble_cd(), assemble_divgrad(), assemble_ellipticdg(), assemble_func(), assemble_helmholtz(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_stokes(), assemble_wave(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), libMesh::NewmarkSystem::clear(), libMesh::EquationSystems::clear(), libMesh::FrequencySystem::clear_all(), compute_jacobian(), compute_residual(), LinearElasticityWithContact::compute_stresses(), LargeDeformationElasticity::compute_stresses(), libMesh::EquationSystems::EquationSystems(), fe_assembly(), fill_dirichlet_bc(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::ImplicitSystem::get_linear_solve_parameters(), libMesh::FEComputeData::init(), init_cd(), HeatSystem::init_data(), libMesh::FrequencySystem::init_data(), init_sys(), initialize(), LargeDeformationElasticity::jacobian(), line_print(), main(), libMesh::FrequencySystem::n_frequencies(), libMesh::NewmarkSystem::NewmarkSystem(), libMesh::NonlinearImplicitSystem::NonlinearImplicitSystem(), LargeDeformationElasticity::residual(), LinearElasticityWithContact::residual_and_jacobian(), run_timestepping(), libMesh::FrequencySystem::set_current_frequency(), libMesh::FrequencySystem::set_frequencies(), libMesh::FrequencySystem::set_frequencies_by_range(), libMesh::FrequencySystem::set_frequencies_by_steps(), set_initial_condition(), libMesh::NewmarkSystem::set_newmark_parameters(), libMesh::NonlinearImplicitSystem::set_solver_parameters(), setup(), SolidSystem::side_time_derivative(), libMesh::RBConstruction::solve_for_matrix_and_rhs(), libMesh::EigenSystem::solve_helper(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), MeshFunctionTest::test_subdomain_id_sets(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), SystemsTest::testProjectCube(), SystemsTest::testProjectCubeWithMeshFunction(), MeshInputTest::testProjectionRegression(), SystemsTest::testProjectLine(), SystemsTest::testProjectSquare(), EquationSystemsTest::testRepartitionThenReinit(), SystemsTest::testSetSystemParameterOverEquationSystem(), MeshInputTest::testSingleElementImpl(), and libMesh::WrappedFunction< Output >::WrappedFunction().

The documentation for this class was generated from the following files:
Generated on Thu Jul 17 2025 01:29:12 for libMesh by   doxygen 1.8.14