This is the EquationSystems class. More...

#include <equation_systems.h>

Inheritance diagram for libMesh::EquationSystems:

Public Types
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
	EquationSystems (MeshBase &mesh)
	Constructor.

virtual	~EquationSystems ()
	Destructor.

virtual void	clear ()
	Restores the data structure to a pristine state.

virtual void	init ()
	Initialize all the systems.

virtual void	reinit ()
	Handle any mesh changes and reinitialize all the systems on the updated mesh.

virtual void	reinit_mesh ()
	Handle the association of a completely new mesh with the EquationSystem and all the Systems assigned to it.

virtual void	enable_default_ghosting (bool enable)
	Enable or disable default ghosting functors on the Mesh and on all Systems.

void	update ()
	Updates local values for all the systems.

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.

template<typename T_sys >
T_sys &	add_system (std::string_view name)
	Add the system named `name` to the systems array.

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.

virtual void	adjoint_solve (const QoISet &qoi_indices=QoISet())
	Call `adjoint_solve` on all the individual equation systems.

virtual void	sensitivity_solve (const ParameterVector &parameters)
	Call `sensitivity_solve` on all the individual equation systems.

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.

void	build_elemental_data_variable_names (std::vector< std::string > &var_names, const std::set< std::string > *system_names=nullptr) const
	Filter `var_names` to names of variables that can be represented as elemental data.

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`.

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.

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.

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`.

void	build_elemental_solution_vector (std::vector< Number > &soln, std::vector< std::string > &names) const
	Retrieve the solution data for elemental data variables.

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.

std::vector< std::pair< unsigned int, unsigned int > >	find_elemental_data_variable_numbers (std::vector< std::string > &names) const
	Finds system and variable numbers for variables that can be represented as elemental data.

std::unique_ptr< NumericVector< Number > >	build_parallel_elemental_solution_vector (std::vector< std::string > &names) const
	Builds a parallel vector of elemental data solution values corresponding to the entries in the input 'names' vector.

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.

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.

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.

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.

const MeshBase &	get_mesh () const

MeshBase &	get_mesh ()

void	allgather ()
	Serializes a distributed mesh and its associated degree of freedom numbering for all systems.

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

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

bool	refine_in_reinit_flag ()

bool	reinit_solutions ()
	Handle any mesh changes and project any solutions onto the updated mesh.

virtual void	reinit_systems ()
	Reinitialize all systems on the current mesh.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static bool	is_elemental_data_fe_type (const FEType &type)

static bool	redundant_added_side (const Elem &elem, unsigned int side)

static std::string	get_info ()
	Gets a string containing the reference information.

static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to `libMesh::out`.

static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.

static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().

static void	disable_print_counter_info ()

Public Attributes
Parameters	parameters
	Data structure holding arbitrary parameters.

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

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.

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

Protected Attributes
MeshBase &	_mesh
	The mesh data structure.

std::map< std::string, std::unique_ptr< System >, std::less<> >	_systems
	Data structure holding the systems.

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

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

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.

static Threads::atomic< unsigned int >	_n_objects
	The number of objects.

static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.

static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Member Functions
std::vector< std::pair< unsigned int, unsigned int > >	find_variable_numbers_by_predicate (std::vector< std::string > &names, const std::function< bool(const FEType &)> &type_filter) const
	Implementation detail for find_variable_numbers() variants.

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 the Mesh, adding the system to each one.

void	_remove_default_ghosting (unsigned int sys_num)
	This just calls DofMap::remove_default_ghosting() but using a shim lets us forward-declare DofMap.

Friends
std::ostream &	operator<< (std::ostream &os, const EquationSystems &es)
	Same as above, but allows you to also use stream syntax.

Detailed Description

This is the EquationSystems class.

It is in charge of handling all the various equation systems defined for a MeshBase. It may have multiple systems, which may be active or inactive, so that at different solution stages only a sub-set may be solved for. Also, through the templated access, different types of systems may be handled. Also other features, like flags, parameters, I/O etc are provided.

Author: Benjamin S. Kirk

Date: 2002-2007

Manages multiples systems of equations.

Definition at line 69 of file equation_systems.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

◆ ReadFlags

enum libMesh::EquationSystems::ReadFlags

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 78 of file equation_systems.h.

                 { READ_HEADER           = 1,
                   READ_DATA             = 2,
                   READ_ADDITIONAL_DATA  = 4,
                   READ_LEGACY_FORMAT    = 8,
                   TRY_READ_IFEMS        = 16,
                   READ_BASIC_ONLY       = 32 };

◆ WriteFlags

enum libMesh::EquationSystems::WriteFlags

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

Enumerator
WRITE_DATA
WRITE_ADDITIONAL_DATA
WRITE_PARALLEL_FILES
WRITE_SERIAL_FILES

Definition at line 88 of file equation_systems.h.

                  { WRITE_DATA             = 1,
                    WRITE_ADDITIONAL_DATA  = 2,
                    WRITE_PARALLEL_FILES   = 4,
                    WRITE_SERIAL_FILES     = 8 };

Constructor & Destructor Documentation

◆ EquationSystems()

libMesh::EquationSystems::EquationSystems ( MeshBase & mesh )

Constructor.

Definition at line 52 of file equation_systems.C.

                                              :
  ParallelObject (m),
  _mesh          (m),
  _refine_in_reinit(true),
  _enable_default_ghosting(true)
{
  // Set default parameters
  this->parameters.set<Real>        ("linear solver tolerance") = TOLERANCE * TOLERANCE;
  this->parameters.set<unsigned int>("linear solver maximum iterations") = 5000;
}

References parameters, libMesh::Real, libMesh::Parameters::set(), and libMesh::TOLERANCE.

◆ ~EquationSystems()

libMesh::EquationSystems::~EquationSystems ( )

virtualdefault

Destructor.

Should be virtual, since the user may want to derive subclasses of EquationSystems.

Member Function Documentation

◆ _add_system_to_nodes_and_elems()

void libMesh::EquationSystems::_add_system_to_nodes_and_elems ( )

private

This function is used in the implementation of add_system, it loops over the nodes and elements of the Mesh, adding the system to each one.

The main reason to separate this part is to avoid coupling this header file to mesh.h, and elem.h.

Definition at line 1879 of file equation_systems.C.

{
  // All the nodes
  for (auto & node : _mesh.node_ptr_range())
    node->add_system();
 
  // All the elements
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [](const ElemRange & range)
     {
       for (Elem * elem : range)
         elem->add_system();
     });
}

Referenced by add_system().

◆ _remove_default_ghosting()

void libMesh::EquationSystems::_remove_default_ghosting ( unsigned int sys_num )

private

This just calls DofMap::remove_default_ghosting() but using a shim lets us forward-declare DofMap.

Definition at line 1895 of file equation_systems.C.

{
  this->get_system(sys_num).get_dof_map().remove_default_ghosting();
}

Referenced by add_system().

◆ add_system() [1/2]

template<typename T_sys >

T_sys & libMesh::EquationSystems::add_system ( std::string_view name )

inline

Add the system named name to the systems array.

Definition at line 690 of file equation_systems.h.

{
  if (!_systems.count(name))
    {
      const unsigned int sys_num = this->n_systems();
 
      auto result = _systems.emplace
        (name, std::make_unique<T_sys>(*this, std::string(name),
                                       sys_num));
 
      if (!_enable_default_ghosting)
        this->_remove_default_ghosting(sys_num);
 
      // Tell all the \p DofObject entities to add a system.
      this->_add_system_to_nodes_and_elems();
 
      // Return reference to newly added item
      auto it = result.first;
      auto & sys_ptr = it->second;
      return cast_ref<T_sys &>(*sys_ptr);
    }
  else
    {
      // We now allow redundant add_system calls, to make it
      // easier to load data from files for user-derived system
      // subclasses
      return this->get_system<T_sys>(name);
    }
}

References _add_system_to_nodes_and_elems(), _enable_default_ghosting, _remove_default_ghosting(), _systems, and n_systems().

◆ add_system() [2/2]

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

virtual

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

Definition at line 353 of file equation_systems.C.

{
  // If the user already built a system with this name, we'll
  // trust them and we'll use it.  That way they can pre-add
  // non-standard derived system classes, and if their restart file
  // has some non-standard sys_type we won't throw an error.
  if (_systems.count(name))
    {
      return this->get_system(name);
    }
  // Build a basic System
  else if (sys_type == "Basic")
    this->add_system<System> (name);
 
  // Build a Newmark system
  else if (sys_type == "Newmark")
    this->add_system<NewmarkSystem> (name);
 
  // Build an Explicit system
  else if ((sys_type == "Explicit"))
    this->add_system<ExplicitSystem> (name);
 
  // Build an Implicit system
  else if ((sys_type == "Implicit") ||
           (sys_type == "Steady"  ))
    this->add_system<ImplicitSystem> (name);
 
  // build a transient implicit linear system
  else if ((sys_type == "Transient") ||
           (sys_type == "TransientImplicit") ||
           (sys_type == "TransientLinearImplicit"))
    this->add_system<TransientLinearImplicitSystem> (name);
 
  // build a transient implicit nonlinear system
  else if (sys_type == "TransientNonlinearImplicit")
    this->add_system<TransientNonlinearImplicitSystem> (name);
 
  // build a transient explicit system
  else if (sys_type == "TransientExplicit")
    this->add_system<TransientExplicitSystem> (name);
 
  // build a linear implicit system
  else if (sys_type == "LinearImplicit")
    this->add_system<LinearImplicitSystem> (name);
 
  // build a nonlinear implicit system
  else if (sys_type == "NonlinearImplicit")
    this->add_system<NonlinearImplicitSystem> (name);
 
  // build a Reduced Basis Construction system
  else if (sys_type == "RBConstruction")
    this->add_system<RBConstruction> (name);
 
  // build a transient Reduced Basis Construction system
  else if (sys_type == "TransientRBConstruction")
    this->add_system<TransientRBConstruction> (name);
 
#ifdef LIBMESH_HAVE_SLEPC
  // build an eigen system
  else if (sys_type == "Eigen")
    this->add_system<EigenSystem> (name);
  else if (sys_type == "TransientEigenSystem")
    this->add_system<TransientEigenSystem> (name);
#endif
 
#if defined(LIBMESH_USE_COMPLEX_NUMBERS)
  // build a frequency system
  else if (sys_type == "Frequency")
    this->add_system<FrequencySystem> (name);
#endif
 
  else
    libmesh_error_msg("ERROR: Unknown system type: " << sys_type);
 
  // Return a reference to the new system
  //return (*this)(name);
  return this->get_system(name);
}

References _systems, and get_system().

Referenced by assemble_and_solve(), build_system(), main(), main(), libMesh::ErrorVector::plot_error(), read(), libMesh::StaticCondensationDofMap::reinit(), TimeSolverTestImplementation< TimeSolverType >::run_test_with_exact_soln(), libMesh::PetscPreconditioner< T >::set_hypre_ads_data(), libMesh::PetscPreconditioner< T >::set_hypre_ams_data(), setup(), WriteVecAndScalar::setupTests(), SystemsTest::simpleSetup(), MultiEvaluablePredTest::test(), SystemsTest::test100KVariables(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), SystemsTest::test2DProjectVectorFE(), SystemsTest::test3DProjectVectorFE(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ProjectSolutionTest::test_partial_project_solution(), MeshFunctionTest::test_subdomain_id_sets(), EquationSystemsTest::testAddSystem(), DofMapTest::testArrayDofIndicesWithType(), 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(), SystemsTest::testFirstScalarNumber(), 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::testProjectScalarCoarsening(), SystemsTest::testProjectSquare(), InfFERadialTest::testRefinement(), EquationSystemsTest::testRefineThenReinitPreserveFlags(), EquationSystemsTest::testReinitWithNodeElem(), EquationSystemsTest::testRepartitionThenReinit(), EquationSystemsTest::testSelectivePRefine(), SystemsTest::testSetSystemParameterOverEquationSystem(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), DisjointNeighborTest::testTempJump(), DisjointNeighborTest::testTempJumpRefine(), WriteVecAndScalar::testWriteExodus(), and WriteVecAndScalar::testWriteNemesis().

◆ adjoint_solve()

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

virtual

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 455 of file equation_systems.C.

{
  libmesh_assert (this->n_systems());
 
  for (unsigned int i=this->n_systems(); i != 0; --i)
    this->get_system(i-1).adjoint_solve(qoi_indices);
}

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

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

◆ allgather()

void libMesh::EquationSystems::allgather ( )

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

Definition at line 275 of file equation_systems.C.

{
  // A serial mesh means nothing needs to be done
  if (_mesh.is_serial())
    return;
 
  const unsigned int n_sys = this->n_systems();
 
  libmesh_assert_not_equal_to (n_sys, 0);
 
  // Gather the mesh
  _mesh.allgather();
 
  // Tell all the \p DofObject entities how many systems
  // there are.
  for (auto & node : _mesh.node_ptr_range())
    node->set_n_systems(n_sys);
 
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [n_sys](const ElemRange & range)
     {
       for (Elem * elem : range)
         elem->set_n_systems(n_sys);
     });
 
  // And distribute each system's dofs
  for (auto i : make_range(this->n_systems()))
    {
      System & sys = this->get_system(i);
      DofMap & dof_map = sys.get_dof_map();
      dof_map.distribute_dofs(_mesh);
 
      // The user probably won't need constraint equations or the
      // send_list after an allgather, but let's keep it in consistent
      // shape just in case.
      sys.reinit_constraints();
 
      // Even if there weren't any constraint changes,
      // reinit_constraints() did prepare_send_list() for us.
    }
}

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

◆ 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

Fill the input vector soln with solution values.

The entries will be in geometry-major format: element, then local node/vertex, then variable.

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 1356 of file equation_systems.C.

{
  LOG_SCOPE("build_discontinuous_solution_vector()", "EquationSystems");
 
  libmesh_assert (this->n_systems());
 
  const std::vector<std::string> component_suffix = {"_x", "_y", "_z"};
  const auto requested_components =
    [this, var_names, &component_suffix](const System & system,
                                         const unsigned int var)
    {
      std::vector<unsigned int> components;
 
      const std::string & var_name = system.variable_name(var);
      const FEType & fe_type = system.variable_type(var);
      const unsigned int n_vec_dim = FEInterface::n_vec_dim(_mesh, fe_type);
 
      if (FEInterface::field_type(fe_type) == TYPE_VECTOR)
        {
          libmesh_error_msg_if(n_vec_dim > component_suffix.size(),
                               "Invalid dim in build_discontinuous_solution_vector");
 
          const bool use_all_components =
            (var_names == nullptr) ||
            std::count(var_names->begin(), var_names->end(), var_name);
 
          if (n_vec_dim <= 1)
            {
              if (use_all_components)
                components.push_back(0);
            }
          else
            for (auto comp : make_range(n_vec_dim))
              {
                const std::string component_name = var_name + component_suffix[comp];
                if (use_all_components ||
                    std::count(var_names->begin(), var_names->end(), component_name))
                  components.push_back(comp);
              }
        }
      else if (var_names == nullptr ||
               std::count(var_names->begin(), var_names->end(), var_name))
        components.push_back(0);
 
      return components;
    };
 
  // Get the number of variables (nv) by counting the number of variables
  // in each system listed in system_names
  unsigned int nv = 0;
 
  for (const auto & [sys_name, sys_ptr] : _systems)
    {
      // Check current system is listed in system_names, and skip pos if not
      bool use_current_system = (system_names == nullptr);
      if (!use_current_system)
        use_current_system = system_names->count(sys_name);
      if (!use_current_system || sys_ptr->hide_output())
        continue;
 
      // Loop over all variables in this System and check whether we
      // are supposed to use each one.
      for (auto var_id : make_range(sys_ptr->n_vars()))
        nv += cast_int<unsigned int>(requested_components(*sys_ptr, var_id).size());
    }
 
  // get the total "weight" - the number of nodal values to write for
  // each variable.
  unsigned int tw=0;
  for (const auto & elem : _mesh.active_element_ptr_range())
    {
      tw += vertices_only ? elem->n_vertices() : elem->n_nodes();
 
      if (add_sides)
        {
          for (auto s : elem->side_index_range())
            {
              if (redundant_added_side(*elem,s))
                continue;
 
              const std::vector<unsigned int> side_nodes =
                elem->nodes_on_side(s);
 
              if (!vertices_only)
                tw += side_nodes.size();
              else
                for (auto n : index_range(side_nodes))
                  if (elem->is_vertex(side_nodes[n]))
                    ++tw;
            }
        }
    }
 
  // Only if we are on processor zero, allocate the storage
  // to hold (number_of_nodes)*(number_of_variables) entries.
  if (_mesh.processor_id() == 0)
    soln.resize(tw*nv);
 
  std::vector<Number> sys_soln;
 
  // Keep track of the variable "offset". This is used for indexing
  // into the global solution vector.
  unsigned int var_offset = 0;
 
  // For each system in this EquationSystems object,
  // update the global solution and if we are on processor 0,
  // loop over the elements and build the nodal solution
  // from the element solution.  Then insert this nodal solution
  // into the vector passed to build_solution_vector.
  for (const auto & [sys_name, system] : _systems)
    {
      // Check current system is listed in system_names, and skip pos if not
      bool use_current_system = (system_names == nullptr);
      if (!use_current_system)
        use_current_system = system_names->count(sys_name);
      if (!use_current_system || system->hide_output())
        continue;
 
      const unsigned int nv_sys = system->n_vars();
      const auto & dof_map = system->get_dof_map();
 
      system->update_global_solution (sys_soln, 0);
 
      // Keep track of the number of vars actually written.
      unsigned int n_vars_written_current_system = 0;
 
      if (_mesh.processor_id() == 0)
        {
          std::vector<Number>       soln_coeffs; // The finite element solution coeffs
          std::vector<Number>       nodal_soln;  // The FE solution interpolated to the nodes
          std::vector<dof_id_type>  dof_indices; // The DOF indices for the finite element
 
          // For each variable, determine if we are supposed to
          // write it, then loop over the active elements, compute
          // the nodal_soln and store it to the "soln" vector. We
          // store zeros for subdomain-restricted variables on
          // elements where they are not active.
          for (auto var : make_range(nv_sys))
            {
              const std::vector<unsigned int> components_to_write =
                requested_components(*system, var);
 
              // If we aren't supposed to write this var, go to the
              // next loop iteration.
              if (components_to_write.empty())
                continue;
 
              const FEType & fe_type = system->variable_type(var);
              const Variable & var_description = system->variable(var);
              const bool add_p_level = fe_type.p_refinement;
              const unsigned int n_vec_dim = FEInterface::n_vec_dim(_mesh, fe_type);
 
              unsigned int nn=0;
 
              for (auto & elem : _mesh.active_element_ptr_range())
                {
                  if (var_description.active_on_subdomain(elem->subdomain_id()))
                    {
                      dof_map.dof_indices (elem, dof_indices, var);
 
                      soln_coeffs.resize(dof_indices.size());
 
                      for (auto i : index_range(dof_indices))
                        soln_coeffs[i] = sys_soln[dof_indices[i]];
 
                      // Compute the FE solution at all the nodes, but
                      // only use the first n_vertices() entries if
                      // vertices_only == true.
                      FEInterface::nodal_soln (elem->dim(),
                                               fe_type,
                                               elem,
                                               soln_coeffs,
                                               nodal_soln,
                                               add_p_level,
                                               n_vec_dim);
 
                      // infinite elements should be skipped...
                      if (!elem->infinite())
                        {
                          libmesh_assert_equal_to (nodal_soln.size(), elem->n_nodes()*n_vec_dim);
 
                          const unsigned int n_vals =
                            vertices_only ? elem->n_vertices() : elem->n_nodes();
 
                          for (auto n : make_range(n_vals))
                            {
                              // Compute index into global solution vector.
                              std::size_t index =
                                nv * (nn++) + (n_vars_written_current_system + var_offset);
 
                              for (auto component_index : index_range(components_to_write))
                                soln[index + component_index] +=
                                  nodal_soln[n_vec_dim*n + components_to_write[component_index]];
                            }
                        }
                    }
                  else
                    nn += vertices_only ? elem->n_vertices() : elem->n_nodes();
                } // end loop over active elements writing interiors
 
              // Loop writing "fake" sides, if requested
              if (add_sides)
                {
                  // We don't build discontinuous solution vectors in
                  // parallel yet, but we'll do ordering of fake side
                  // values as if we did, for consistency with the
                  // parallel continuous ordering and for future
                  // compatibility.
                  std::vector<std::vector<const Elem *>>
                    elems_by_pid(_mesh.n_processors());
 
                  for (const auto & elem : _mesh.active_element_ptr_range())
                    elems_by_pid[elem->processor_id()].push_back(elem);
 
                  for (auto p : index_range(elems_by_pid))
                    for (const Elem * elem : elems_by_pid[p])
                      {
                        if (var_description.active_on_subdomain(elem->subdomain_id()))
                          {
                            dof_map.dof_indices (elem, dof_indices, var);
 
                            soln_coeffs.resize(dof_indices.size());
 
                            for (auto i : index_range(dof_indices))
                              soln_coeffs[i] = sys_soln[dof_indices[i]];
 
                            for (auto s : elem->side_index_range())
                              {
                                if (redundant_added_side(*elem,s))
                                  continue;
 
                                const std::vector<unsigned int> side_nodes =
                                  elem->nodes_on_side(s);
 
                                // Compute the FE solution at all the
                                // side nodes, but only use those for
                                // which is_vertex() == true if
                                // vertices_only == true.
                                FEInterface::side_nodal_soln
                                  (fe_type, elem, s, soln_coeffs,
                                   nodal_soln, add_p_level,
                                   n_vec_dim);
 
                                libmesh_assert_equal_to
                                    (nodal_soln.size(),
                                     side_nodes.size()*n_vec_dim);
 
                                // If we don't have a continuous FE
                                // then we want to average between
                                // sides, at least in the equal-level
                                // case where it's easy.  This is
                                // analogous to our repeat_count
                                // behavior elsewhere.
                                const FEContinuity cont =
                                  FEInterface::get_continuity(fe_type);
                                const Elem * const neigh = elem->neighbor_ptr(s);
 
                                if ((cont == DISCONTINUOUS || cont == H_CURL || cont == H_DIV) &&
                                    neigh &&
                                    neigh->level() == elem->level() &&
                                    var_description.active_on_subdomain(neigh->subdomain_id()))
                                  {
                                    std::vector<dof_id_type> neigh_indices;
                                    dof_map.dof_indices (neigh, neigh_indices, var);
                                    std::vector<Number> neigh_coeffs(neigh_indices.size());
 
                                    for (auto i : index_range(neigh_indices))
                                      neigh_coeffs[i] = sys_soln[neigh_indices[i]];
 
                                    const unsigned int s_neigh =
                                      neigh->which_neighbor_am_i(elem);
                                    std::vector<Number> neigh_soln;
                                    FEInterface::side_nodal_soln
                                      (fe_type, neigh, s_neigh,
                                       neigh_coeffs, neigh_soln, add_p_level,
                                       n_vec_dim);
 
                                    const std::vector<unsigned int> neigh_nodes =
                                      neigh->nodes_on_side(s_neigh);
                                    for (auto n : index_range(side_nodes))
                                      for (auto neigh_n : index_range(neigh_nodes))
                                        if (neigh->node_ptr(neigh_nodes[neigh_n])
                                            == elem->node_ptr(side_nodes[n]))
                                          for (auto comp : make_range(n_vec_dim))
                                            {
                                              const auto nodal_index = n_vec_dim*n + comp;
                                              nodal_soln[nodal_index] +=
                                                neigh_soln[n_vec_dim*neigh_n + comp];
                                              nodal_soln[nodal_index] /= 2;
                                            }
                                  }
 
                                for (auto n : index_range(side_nodes))
                                  {
                                    if (vertices_only &&
                                        !elem->is_vertex(n))
                                      continue;
 
                                    // Compute index into global solution vector.
                                    std::size_t index =
                                      nv * (nn++) + (n_vars_written_current_system + var_offset);
 
                                    for (auto component_index : index_range(components_to_write))
                                      soln[index + component_index] +=
                                        nodal_soln[n_vec_dim*n + components_to_write[component_index]];
                                  }
                              }
                          }
                        else
                          {
                            nn += vertices_only ? elem->n_vertices() : elem->n_nodes();
 
                            for (auto s : elem->side_index_range())
                              {
                                if (redundant_added_side(*elem,s))
                                  continue;
 
                                const std::vector<unsigned int> side_nodes =
                                  elem->nodes_on_side(s);
 
                                for (auto n : index_range(side_nodes))
                                  {
                                    if (vertices_only &&
                                        !elem->is_vertex(n))
                                      continue;
                                    nn++;
                                  }
                              }
                          }
                      } // end loop over active elements, writing "fake" sides
                }
              // If we made it here, we actually wrote a variable, so increment
              // the number of variables actually written for the current system.
              n_vars_written_current_system += cast_int<unsigned int>(components_to_write.size());
 
            } // end loop over vars
        } // end if proc 0
 
      // Update offset for next loop iteration.
      var_offset += n_vars_written_current_system;
    } // end loop over systems
}

References libMesh::Variable::active_on_subdomain(), libMesh::DISCONTINUOUS, libMesh::H_CURL, libMesh::H_DIV, libMesh::index_range(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::nodes_on_side(), libMesh::FEType::p_refinement, libMesh::Elem::subdomain_id(), libMesh::TYPE_VECTOR, and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::ExodusII_IO::write_discontinuous_exodusII(), libMesh::GMVIO::write_discontinuous_gmv(), and libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data().

◆ build_elemental_data_variable_names()

void libMesh::EquationSystems::build_elemental_data_variable_names	(	std::vector< std::string > &	var_names,
		const std::set< std::string > *	system_names = `nullptr`
	)		const

Filter var_names to names of variables that can be represented as elemental data.

If var_names is empty, all eligible variable names are returned. Vector-valued variables are decomposed into component names. If system_names!=nullptr, only include names from the specified systems.

Definition at line 592 of file equation_systems.C.

{
  const std::vector<std::string> name_filter = var_names;
  const bool is_names_empty = name_filter.empty();
  var_names.clear();
 
  const std::vector<std::string> component_suffix = {"_x", "_y", "_z"};
  const unsigned int dim = _mesh.spatial_dimension();
  libmesh_error_msg_if(dim > 3, "Invalid dim in build_elemental_data_variable_names");
 
  for (const auto & [sys_name, sys_ptr] : _systems)
    {
      const bool use_current_system = (system_names == nullptr) || system_names->count(sys_name);
      if (!use_current_system || sys_ptr->hide_output())
        continue;
 
      for (auto var : make_range(sys_ptr->n_vars()))
        {
          const FEType & var_type = sys_ptr->variable_type(var);
          if (!EquationSystems::is_elemental_data_fe_type(var_type))
            continue;
 
          if (FEInterface::field_type(var_type) == TYPE_VECTOR)
            {
              for (auto comp : make_range(dim))
                {
                  const std::string name =
                    sys_ptr->variable_name(var) + component_suffix[comp];
 
                  if (is_names_empty ||
                      std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end())
                    var_names.push_back(name);
                }
            }
          else
            {
              const std::string & name = sys_ptr->variable_name(var);
 
              if (is_names_empty ||
                  std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end())
                var_names.push_back(name);
            }
        }
    }
 
  std::sort(var_names.begin(), var_names.end());
}

References _mesh, _systems, dim, libMesh::FEInterface::field_type(), is_elemental_data_fe_type(), libMesh::make_range(), libMesh::MeshBase::spatial_dimension(), and libMesh::TYPE_VECTOR.

Referenced by libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data().

◆ build_elemental_solution_vector()

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

Retrieve the solution data for elemental data variables.

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 1090 of file equation_systems.C.

{
  // Call the parallel version of this function
  std::unique_ptr<NumericVector<Number>> parallel_soln =
    this->build_parallel_elemental_solution_vector(names);
 
  // Localize into 'soln', provided that parallel_soln is not empty.
  // Note: parallel_soln will be empty in the event that none of the
  // input names were elemental data variables, or there were simply none of these in
  // the EquationSystems object.
  soln.clear();
  if (parallel_soln)
    parallel_soln->localize_to_one(soln);
}

References build_parallel_elemental_solution_vector().

Referenced by libMesh::ExodusII_IO::write_element_data().

◆ build_parallel_elemental_solution_vector()

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

Builds a parallel vector of elemental data 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 elemental data 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 elemental data variables (u, v, w) on a mesh with N elements.

Definition at line 1237 of file equation_systems.C.

{
  // Filter any names that aren't elemental variables and get the system indices for those that are.
  // Note that it's probably fine if the names vector is empty since we'll still filter out all
  // non-elemental-data variables. If there are none, then nothing is output here.
  std::vector<std::pair<unsigned int, unsigned int>> var_nums =
    this->find_elemental_data_variable_numbers(names);
 
  const std::size_t nv = names.size(); /*total number of vars including vector components*/
  const dof_id_type ne = _mesh.n_elem();
  libmesh_assert_equal_to (ne, _mesh.max_elem_id());
 
  // If there are no variables to write out don't do anything...
  if (!nv)
    return std::unique_ptr<NumericVector<Number>>(nullptr);
 
  // We can handle the case where there are nullptrs in the Elem vector
  // by just having extra zeros in the solution vector.
  numeric_index_type parallel_soln_global_size = ne*nv;
 
  numeric_index_type div = parallel_soln_global_size / this->n_processors();
  numeric_index_type mod = parallel_soln_global_size % this->n_processors();
 
  // Initialize all processors to the average size.
  numeric_index_type parallel_soln_local_size = div;
 
  // The first "mod" processors get an extra entry.
  if (this->processor_id() < mod)
    parallel_soln_local_size = div+1;
 
  // Create a NumericVector to hold the parallel solution
  std::unique_ptr<NumericVector<Number>> parallel_soln_ptr = NumericVector<Number>::build(_communicator);
  NumericVector<Number> & parallel_soln = *parallel_soln_ptr;
  parallel_soln.init(parallel_soln_global_size,
                     parallel_soln_local_size,
                     /*fast=*/false,
                     /*ParallelType=*/PARALLEL);
 
  unsigned int sys_ctr = 0;
  unsigned int var_ctr = 0;
  for (auto i : index_range(var_nums))
    {
      std::pair<unsigned int, unsigned int> var_num = var_nums[i];
      const System & system = this->get_system(var_num.first);
 
      // Update the current_local_solution if necessary
      if (sys_ctr != var_num.first)
        {
          System & non_const_sys = const_cast<System &>(system);
          // We used to simply call non_const_sys.solution->close()
          // here, but that is not allowed when the solution vector is
          // locked read-only, for example when printing the solution
          // during during the middle of a solve...  So try to be a bit
          // more careful about calling close() unnecessarily.
          libmesh_assert(this->comm().verify(non_const_sys.solution->closed()));
          if (!non_const_sys.solution->closed())
            non_const_sys.solution->close();
          non_const_sys.update();
          sys_ctr = var_num.first;
        }
 
      NumericVector<Number> & sys_soln(*system.current_local_solution);
 
      const unsigned int var = var_num.second;
 
      const Variable & variable = system.variable(var);
      const DofMap & dof_map = system.get_dof_map();
 
      // We need to check if the elemental data variable is a scalar or a vector and set the number of
      // components for the latter as per es.find_variable_numbers().
      // Even for the case where a variable is not active on any subdomain belonging to the
      // processor, we still need to know this number to update 'var_ctr'.
      const auto & var_type = system.variable_type(var);
      const unsigned int n_comps =
        (FEInterface::field_type(var_type) == TYPE_VECTOR) ?
        FEInterface::n_vec_dim(_mesh, var_type) : 1;
 
      // Loop over all elements in the mesh and index all components of the variable if it's active
      Threads::parallel_for
        (_mesh.active_local_element_stored_range(),
         [&dof_map, &variable, ne, var, var_ctr, n_comps,
         &parallel_soln, &sys_soln](const ConstElemRange & range)
         {
           // The DOF indices for the finite element
           std::vector<dof_id_type> dof_indices;
 
           for (const Elem * elem : range)
             {
               if (variable.active_on_subdomain(elem->subdomain_id()))
                 {
                   dof_map.dof_indices(elem, dof_indices, var);
 
                   // The number of DOF components needs to be equal to the expected number so that we know
                   // where to store data to correctly correspond to variable names.
                   libmesh_assert_equal_to(dof_indices.size(), n_comps);
 
                   for (unsigned int comp = 0; comp < n_comps; comp++)
                     parallel_soln.set(ne * (var_ctr + comp) + elem->id(), sys_soln(dof_indices[comp]));
                 }
             }
         });
 
      var_ctr += n_comps;
    } // end loop over var_nums
 
  // NOTE: number of output names might not be equal to the number passed to this function. Any that
  // aren't elemental data variables have been filtered out (see
  // EquationSystems::find_variable_numbers).
  //
  // But, if everything is accounted for properly, then names.size() == var_ctr
  libmesh_assert_equal_to(names.size(), var_ctr);
 
  parallel_soln.close();
  return parallel_soln_ptr;
}

References libMesh::ParallelObject::_communicator, _mesh, libMesh::MeshBase::active_local_element_stored_range(), libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::FEInterface::field_type(), find_elemental_data_variable_numbers(), libMesh::System::get_dof_map(), get_system(), libMesh::index_range(), libMesh::NumericVector< T >::init(), libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::n_elem(), libMesh::ParallelObject::n_processors(), libMesh::FEInterface::n_vec_dim(), libMesh::PARALLEL, libMesh::Threads::parallel_for(), libMesh::ParallelObject::processor_id(), libMesh::System::solution, libMesh::TYPE_VECTOR, libMesh::System::update(), libMesh::System::variable(), and libMesh::System::variable_type().

Referenced by build_elemental_solution_vector().

◆ 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

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 656 of file equation_systems.C.

{
  LOG_SCOPE("build_parallel_solution_vector()", "EquationSystems");
 
  // This function must be run on all processors at once
  parallel_object_only();
 
  const unsigned int dim = _mesh.spatial_dimension();
  const dof_id_type max_nn   = _mesh.max_node_id();
 
  // allocate vector storage to hold
  // (max_node_id)*(number_of_variables) entries.
  //
  // If node renumbering is disabled and adaptive coarsening has
  // created gaps between node numbers, then this vector will be
  // sparse.
  //
  // We have to differentiate between between scalar and vector
  // variables. We intercept vector variables and treat each
  // component as a scalar variable (consistently with build_solution_names).
 
  unsigned int nv = 0;
 
  //Could this be replaced by a/some convenience methods?[PB]
  {
    unsigned int n_scalar_vars = 0;
    unsigned int n_vector_vars = 0;
    for (const auto & [sys_name, sys_ptr] : _systems)
      {
        // Check current system is listed in system_names, and skip pos if not
        bool use_current_system = (system_names == nullptr);
        if (!use_current_system)
          use_current_system = system_names->count(sys_name);
        if (!use_current_system || sys_ptr->hide_output())
          continue;
 
        for (auto vn : make_range(sys_ptr->n_vars()))
          {
            if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
              n_vector_vars++;
            else
              n_scalar_vars++;
          }
      }
    // Here, we're assuming the number of vector components is the same
    // as the mesh spatial dimension.
    nv = n_scalar_vars + dim*n_vector_vars;
  }
 
  // Get the number of nodes to store locally.
  dof_id_type n_local_nodes = cast_int<dof_id_type>
    (std::distance(_mesh.local_nodes_begin(),
                   _mesh.local_nodes_end()));
 
  // If node renumbering has been disabled, nodes may not be numbered
  // contiguously, and the number of nodes might not match the
  // max_node_id.  In this case we just do our best.
  dof_id_type n_total_nodes = n_local_nodes;
  _mesh.comm().sum(n_total_nodes);
 
  const processor_id_type n_proc = _mesh.comm().size();
  const processor_id_type my_pid = _mesh.comm().rank();
  const dof_id_type n_gaps = max_nn - n_total_nodes;
  const dof_id_type gaps_per_processor = n_gaps / n_proc;
  const dof_id_type remainder_gaps = n_gaps % n_proc;
 
  n_local_nodes = n_local_nodes +      // Actual nodes
                  gaps_per_processor + // Our even share of gaps
                  (my_pid < remainder_gaps); // Leftovers
 
  // If we've been asked to build added sides' data, we need space to
  // add it.  Keep track of how much space.
  dof_id_type local_added_side_nodes = 0,
              added_side_nodes = 0;
 
  // others_added_side_nodes[p]: local_added_side_nodes on rank p
  std::vector<dof_id_type> others_added_side_nodes;
 
  // A map of (element_id, side, side_node) pairs to the corresponding
  // added side node index.
  std::map<std::tuple<dof_id_type, unsigned short, unsigned short>,
           dof_id_type> discontinuous_node_indices;
 
  // If we don't have any added side nodes, we'll have no offsets from
  // them, and we won't care about which offsets apply to which node
  // ids either.
 
  // Number of true nodes on processors [0,p]
  std::vector<dof_id_type> true_node_offsets;
  // Number of added (fake) nodes on processors [0,p)
  std::vector<dof_id_type> added_node_offsets;
 
  auto node_id_to_vec_id =
    [&true_node_offsets, &added_node_offsets]
    (const dof_id_type node_id)
    {
      if (true_node_offsets.empty())
        return node_id; // O(1) in the common !add_sides case
 
      // Find the processor id that has node_id in the parallel vec
      const auto lb = std::upper_bound(true_node_offsets.begin(),
                                       true_node_offsets.end(), node_id);
      libmesh_assert(lb != true_node_offsets.end());
      const processor_id_type p = lb - true_node_offsets.begin();
 
      return node_id + added_node_offsets[p];
    };
 
  if (add_sides)
    {
      true_node_offsets.resize(n_proc);
      added_node_offsets.resize(n_proc);
 
      // One loop to count everyone's new side nodes
      for (const auto & elem : _mesh.active_element_ptr_range())
        {
          for (auto s : elem->side_index_range())
            {
              if (redundant_added_side(*elem,s))
                continue;
 
              const std::vector<unsigned int> side_nodes =
                elem->nodes_on_side(s);
 
              if (elem->processor_id() == this->processor_id())
                local_added_side_nodes += side_nodes.size();
            }
        }
 
      others_added_side_nodes.resize(n_proc);
      _mesh.comm().allgather(local_added_side_nodes,
                             others_added_side_nodes);
 
      added_side_nodes = std::accumulate(others_added_side_nodes.begin(),
                                         others_added_side_nodes.end(), 0,
                                         std::plus<>());
 
      _mesh.comm().allgather(n_local_nodes, true_node_offsets);
      for (auto p : make_range(n_proc-1))
        true_node_offsets[p+1] += true_node_offsets[p];
      libmesh_assert_equal_to(true_node_offsets[n_proc-1], _mesh.max_node_id());
 
      // For nodes that exist in the mesh, we just need an offset to
      // tell where to put their solutions.
      added_node_offsets[0] = 0;
      for (auto p : make_range(n_proc-1))
        added_node_offsets[p+1] =
          added_node_offsets[p] + others_added_side_nodes[p];
 
      // For added side nodes, we need to fill a map.  Start after all
      // the true node for our pid plus all the side nodes for
      // previous pids
      dof_id_type node_counter = true_node_offsets[my_pid];
      for (auto p : make_range(my_pid))
        node_counter += others_added_side_nodes[p];
 
      // One loop to figure out whose added side nodes get which index
      for (const auto & elem : _mesh.active_local_element_ptr_range())
        {
          for (auto s : elem->side_index_range())
            {
              if (redundant_added_side(*elem,s))
                continue;
 
              const std::vector<unsigned int> side_nodes =
                elem->nodes_on_side(s);
 
              for (auto n : index_range(side_nodes))
                discontinuous_node_indices
                  [std::make_tuple(elem->id(),s,n)] = node_counter++;
            }
        }
    }
 
  const dof_id_type
    n_global_vals = (max_nn + added_side_nodes) * nv,
    n_local_vals = (n_local_nodes + local_added_side_nodes) * nv;
 
  // Create a NumericVector to hold the parallel solution
  std::unique_ptr<NumericVector<Number>> parallel_soln_ptr = NumericVector<Number>::build(_communicator);
  NumericVector<Number> & parallel_soln = *parallel_soln_ptr;
  parallel_soln.init(n_global_vals, n_local_vals, false, PARALLEL);
 
  // Create a NumericVector to hold the "repeat_count" for each node - this is essentially
  // the number of elements contributing to that node's value
  std::unique_ptr<NumericVector<Number>> repeat_count_ptr = NumericVector<Number>::build(_communicator);
  NumericVector<Number> & repeat_count = *repeat_count_ptr;
  repeat_count.init(n_global_vals, n_local_vals, false, PARALLEL);
 
  repeat_count.close();
 
  unsigned int var_num=0;
 
  // For each system in this EquationSystems object,
  // update the global solution and if we are on processor 0,
  // loop over the elements and build the nodal solution
  // from the element solution.  Then insert this nodal solution
  // into the vector passed to build_solution_vector.
  for (const auto & [sys_name, sys_ptr] : _systems)
    {
      // Check current system is listed in system_names, and skip pos if not
      bool use_current_system = (system_names == nullptr);
      if (!use_current_system)
        use_current_system = system_names->count(sys_name);
      if (!use_current_system || sys_ptr->hide_output())
        continue;
 
      const System & system  = *sys_ptr;
      const unsigned int nv_sys = system.n_vars();
      const unsigned int sys_num = system.number();
 
      //Could this be replaced by a/some convenience methods?[PB]
      unsigned int n_scalar_vars = 0;
      unsigned int n_vector_vars = 0;
      for (auto vn : make_range(sys_ptr->n_vars()))
        {
          if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
            n_vector_vars++;
          else
            n_scalar_vars++;
        }
 
      // Here, we're assuming the number of vector components is the same
      // as the mesh spatial dimension.
      unsigned int nv_sys_split = n_scalar_vars + dim*n_vector_vars;
 
      // Update the current_local_solution
      {
        System & non_const_sys = const_cast<System &>(system);
        // We used to simply call non_const_sys.solution->close()
        // here, but that is not allowed when the solution vector is
        // locked read-only, for example when printing the solution
        // during the middle of a solve...  So try to be a bit
        // more careful about calling close() unnecessarily.
        libmesh_assert(this->comm().verify(non_const_sys.solution->closed()));
        if (!non_const_sys.solution->closed())
          non_const_sys.solution->close();
        non_const_sys.update();
      }
 
      NumericVector<Number> & sys_soln(*system.current_local_solution);
 
      const DofMap & dof_map = system.get_dof_map();
 
      std::vector<Number>      elem_soln;   // The finite element solution
      std::vector<Number>      nodal_soln;  // The FE solution interpolated to the nodes
      std::vector<dof_id_type> dof_indices; // The DOF indices for the finite element
 
      unsigned var_inc = 0;
      for (unsigned int var=0; var<nv_sys; var++)
        {
          const FEType & fe_type           = system.variable_type(var);
          const Variable & var_description = system.variable(var);
          unsigned int n_vec_dim = FEInterface::n_vec_dim( sys_ptr->get_mesh(), fe_type );
          const bool add_p_level = fe_type.p_refinement;
 
          for (const auto & elem : _mesh.active_local_element_ptr_range())
            {
              if (var_description.active_on_subdomain(elem->subdomain_id()))
                {
                  dof_map.dof_indices (elem, dof_indices, var);
                  sys_soln.get(dof_indices, elem_soln);
 
                  FEInterface::nodal_soln (elem->dim(),
                                           fe_type,
                                           elem,
                                           elem_soln,
                                           nodal_soln,
                                           add_p_level,
                                           n_vec_dim);
 
                  // infinite elements should be skipped...
                  if (!elem->infinite())
                    {
                      libmesh_assert_equal_to (nodal_soln.size(), n_vec_dim*elem->n_nodes());
 
                      for (auto n : elem->node_index_range())
                        {
                          const Node & node = elem->node_ref(n);
 
                          const dof_id_type node_idx =
                            nv * node_id_to_vec_id(node.id());
 
                          for (unsigned int d=0; d < n_vec_dim; d++)
                            {
                              // For vector-valued elements, all components are in nodal_soln. For each
                              // node, the components are stored in order, i.e. node_0 -> s0_x, s0_y, s0_z
                              parallel_soln.add(node_idx + (var_inc+d + var_num), nodal_soln[n_vec_dim*n+d]);
 
                              // Increment the repeat count for this position
                              repeat_count.add(node_idx + (var_inc+d + var_num), 1);
                            }
                        }
 
                      if (add_sides)
                        {
                          for (auto s : elem->side_index_range())
                            {
                              if (redundant_added_side(*elem,s))
                                continue;
 
                              // Compute the FE solution at all the
                              // side nodes
                              FEInterface::side_nodal_soln
                                (fe_type, elem, s, elem_soln,
                                 nodal_soln, add_p_level, n_vec_dim);
 
#ifdef DEBUG
                              const std::vector<unsigned int> side_nodes =
                                elem->nodes_on_side(s);
 
                              libmesh_assert_equal_to
                                  (nodal_soln.size(),
                                   side_nodes.size());
#endif
 
                              for (auto n : index_range(nodal_soln))
                                {
                                  // Retrieve index into global solution vector.
                                  std::size_t node_index =
                                    nv * libmesh_map_find(discontinuous_node_indices,
                                                          std::make_tuple(elem->id(), s, n));
 
                                  for (unsigned int d=0; d < n_vec_dim; d++)
                                    {
                                      parallel_soln.add(node_index + (var_inc+d + var_num), nodal_soln[n_vec_dim*n+d]);
                                      repeat_count.add(node_index + (var_inc+d + var_num), 1);
                                    }
                                }
                            }
                        }
                    }
                }
              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:
                for (auto n : elem->node_index_range())
                  {
                    const Node & node = elem->node_ref(n);
                    // Only do this if this variable has NO DoFs at
                    // this node... it might have some from an
                    // adjoining element...
                    if (!node.n_dofs(sys_num, var))
                      {
                        const dof_id_type node_idx =
                          nv * node_id_to_vec_id(node.id());
 
                        for (unsigned int d=0; d < n_vec_dim; d++)
                          repeat_count.add(node_idx + (var_inc+d + var_num), 1);
                      }
                  }
 
            } // end loop over elements
          var_inc += n_vec_dim;
        } // end loop on variables in this system
 
      var_num += nv_sys_split;
    } // end loop over systems
 
  // Sum the nodal solution values and repeat counts.
  parallel_soln.close();
  repeat_count.close();
 
  // If there were gaps in the node numbering, there will be
  // corresponding zeros in the parallel_soln and repeat_count
  // vectors.  We need to set those repeat_count entries to 1
  // in order to avoid dividing by zero.
  if (n_gaps)
    {
      for (numeric_index_type i=repeat_count.first_local_index();
           i<repeat_count.last_local_index(); ++i)
        {
          // repeat_count entries are integral values but let's avoid a
          // direct floating point comparison with 0 just in case some
          // roundoff noise crept in during vector assembly?
          if (std::abs(repeat_count(i)) < TOLERANCE)
            repeat_count.set(i, 1.);
        }
 
      // Make sure the repeat_count vector is up-to-date on all
      // processors.
      repeat_count.close();
    }
 
  // Divide to get the average value at the nodes
  parallel_soln /= repeat_count;
 
  return parallel_soln_ptr;
}

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

◆ build_solution_vector() [1/2]

void libMesh::EquationSystems::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.

The entries will be in node-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 1047 of file equation_systems.C.

{
  LOG_SCOPE("build_solution_vector()", "EquationSystems");
 
  // Call the parallel implementation
  std::unique_ptr<NumericVector<Number>> parallel_soln =
    this->build_parallel_solution_vector(system_names, add_sides);
 
  // Localize the NumericVector into the provided std::vector.
  parallel_soln->localize_to_one(soln);
}

References build_parallel_solution_vector().

◆ build_solution_vector() [2/2]

void libMesh::EquationSystems::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.

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 644 of file equation_systems.C.

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

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

◆ 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

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 465 of file equation_systems.C.

{
  // start indexing at end of possibly non-empty vector of variable names to avoid overwriting them
  unsigned int var_num = var_names.size();
 
  // We'll want to double-check that we don't have any naming
  // conflicts; this API causes problems down the line if so.
  std::unordered_multiset<std::string> seen_names;
 
  // Need to size var_names by scalar variables plus all the
  // vector components for all the vector variables
  //Could this be replaced by a/some convenience methods?[PB]
  {
    unsigned int n_scalar_vars = 0;
    unsigned int n_vector_vars = 0;
 
    for (const auto & [sys_name, sys_ptr] : _systems)
      {
        // Check current system is listed in system_names, and skip pos if not
        bool use_current_system = (system_names == nullptr);
        if (!use_current_system)
          use_current_system = system_names->count(sys_name);
        if (!use_current_system || sys_ptr->hide_output())
          {
            for (auto vn : make_range(sys_ptr->n_vars()))
              seen_names.insert(sys_ptr->variable_name(vn));
            continue;
          }
 
        for (auto vn : make_range(sys_ptr->n_vars()))
          {
            seen_names.insert(sys_ptr->variable_name(vn));
            if (FEInterface::field_type(sys_ptr->variable_type(vn)) == TYPE_VECTOR)
              n_vector_vars++;
            else
              n_scalar_vars++;
          }
      }
 
    // Here, we're assuming the number of vector components is the same
    // as the mesh spatial dimension.
    unsigned int dim = this->get_mesh().spatial_dimension();
    unsigned int nv = n_scalar_vars + dim*n_vector_vars;
 
    // We'd better not have more than dim*this->n_vars() (all vector variables)
    // Treat the NodeElem-only mesh case as dim=1
    libmesh_assert_less_equal ( nv, (dim > 0 ? dim : 1)*this->n_vars() );
 
    // 'nv' represents the max possible number of output variables, so allocate enough memory for
    // all variables in the system to be populated here. When this is called more than once on a
    // single 'var_names' vector, different filters should be used such that duplicates don't occur.
    var_names.resize( nv );
  }
 
  for (const auto & [sys_name, sys_ptr] : _systems)
    {
      // Check current system is listed in system_names, and skip pos if not
      bool use_current_system = (system_names == nullptr);
      if (!use_current_system)
        use_current_system = system_names->count(sys_name);
      if (!use_current_system || sys_ptr->hide_output())
        continue;
 
      for (auto vn : make_range(sys_ptr->n_vars()))
        {
          const std::string & var_name = sys_ptr->variable_name(vn);
          const FEType & fe_type = sys_ptr->variable_type(vn);
 
          unsigned int n_vec_dim = FEInterface::n_vec_dim( sys_ptr->get_mesh(), fe_type);
 
          // Filter on the type if requested
          if (type == nullptr || (type && *type == fe_type))
            {
              if (FEInterface::field_type(fe_type) == TYPE_VECTOR)
                {
                  switch(n_vec_dim)
                    {
                    case 0:
                    case 1:
                      var_names[var_num++] = var_name;
                      libmesh_error_msg_if(seen_names.count(var_name) > 1,
                                           "Duplicate variable name "+var_name);
                      break;
                    case 2:
                      var_names[var_num++] = var_name+"_x";
                      var_names[var_num++] = var_name+"_y";
                      libmesh_error_msg_if(seen_names.count(var_name+"_x"),
                                           "Duplicate variable name "+var_name+"_x");
                      libmesh_error_msg_if(seen_names.count(var_name+"_y"),
                                           "Duplicate variable name "+var_name+"_y");
                      break;
                    case 3:
                      var_names[var_num++] = var_name+"_x";
                      var_names[var_num++] = var_name+"_y";
                      var_names[var_num++] = var_name+"_z";
                      libmesh_error_msg_if(seen_names.count(var_name+"_x"),
                                           "Duplicate variable name "+var_name+"_x");
                      libmesh_error_msg_if(seen_names.count(var_name+"_y"),
                                           "Duplicate variable name "+var_name+"_y");
                      libmesh_error_msg_if(seen_names.count(var_name+"_z"),
                                           "Duplicate variable name "+var_name+"_z");
                      break;
                    default:
                      libmesh_error_msg("Invalid dim in build_variable_names");
                    }
                }
              else
                var_names[var_num++] = var_name;
            }
        }
    }
  // Now resize again in case we filtered any names
  var_names.resize(var_num);
}

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

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

◆ clear()

void libMesh::EquationSystems::clear ( )

virtual

Restores the data structure to a pristine state.

Definition at line 69 of file equation_systems.C.

{
  // Clear any additional parameters
  parameters.clear ();
 
  // Clear the systems.
  _systems.clear();
}

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

Referenced by libMesh::ExactSolution::attach_exact_derivs(), libMesh::ExactSolution::attach_exact_hessians(), libMesh::ExactSolution::attach_exact_values(), libMesh::ExactSolution::attach_reference_solution(), and main().

◆ 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.

98 { return _communicator; }

References libMesh::ParallelObject::_communicator.

◆ compare()

bool libMesh::EquationSystems::compare	(	const EquationSystems &	other_es,
		const Real	threshold,
		const bool	verbose
	)		const

virtual

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 1731 of file equation_systems.C.

{
  // safety check, whether we handle at least the same number
  // of systems
  std::vector<bool> os_result;
 
  if (this->n_systems() != other_es.n_systems())
    {
      if (verbose)
        {
          libMesh::out << "  Fatal difference. This system handles "
                       << this->n_systems() << " systems," << std::endl
                       << "  while the other system handles "
                       << other_es.n_systems()
                       << " systems." << std::endl
                       << "  Aborting comparison." << std::endl;
        }
      return false;
    }
  else
    {
      // start comparing each system
      for (const auto & [sys_name, sys_ptr] : _systems)
        {
          // get the other system
          const System & other_system   = other_es.get_system (sys_name);
 
          os_result.push_back (sys_ptr->compare (other_system, threshold, verbose));
 
        }
 
    }
 
 
  // sum up the results
  if (os_result.size()==0)
    return true;
  else
    {
      bool os_identical;
      unsigned int n = 0;
      do
        {
          os_identical = os_result[n];
          n++;
        }
      while (os_identical && n<os_result.size());
      return os_identical;
    }
}

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

Referenced by do_compare().

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

◆ disable_refine_in_reinit()

void libMesh::EquationSystems::disable_refine_in_reinit ( )

inline

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

Definition at line 585 of file equation_systems.h.

585{ this->_refine_in_reinit = false; }

References _refine_in_reinit.

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

◆ enable_default_ghosting()

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

virtual

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 320 of file equation_systems.C.

{
  _enable_default_ghosting = enable;
  MeshBase &mesh = this->get_mesh();
 
  if (enable)
    mesh.add_ghosting_functor(mesh.default_ghosting());
  else
    mesh.remove_ghosting_functor(mesh.default_ghosting());
 
  for (auto i : make_range(this->n_systems()))
    {
      DofMap & dof_map = this->get_system(i).get_dof_map();
      if (enable)
        dof_map.add_default_ghosting();
      else
        dof_map.remove_default_ghosting();
    }
}

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

Referenced by EquationSystemsTest::testDisableDefaultGhosting().

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

◆ enable_refine_in_reinit()

void libMesh::EquationSystems::enable_refine_in_reinit ( )

inline

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

Definition at line 580 of file equation_systems.h.

580{ this->_refine_in_reinit = true; }

References _refine_in_reinit.

◆ find_elemental_data_variable_numbers()

std::vector< std::pair< unsigned int, unsigned int > > libMesh::EquationSystems::find_elemental_data_variable_numbers ( std::vector< std::string > & names ) const

Finds system and variable numbers for variables that can be represented as elemental data.

See find_variable_numbers() for name filtering, component decomposition, and sorting details.

Definition at line 1132 of file equation_systems.C.

{
  return this->find_variable_numbers_by_predicate
    (names, EquationSystems::is_elemental_data_fe_type);
}

References find_variable_numbers_by_predicate(), and is_elemental_data_fe_type().

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

◆ 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

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 1107 of file equation_systems.C.

{
  // Resolve class of type input and assert that at least one of them is null
  libmesh_assert_msg(!type || !types,
                     "Input 'type', 'types', or neither in find_variable_numbers, but not both.");
 
  std::vector<FEType> type_filter;
  if (type)
    type_filter.push_back(*type);
  else if (types)
    type_filter = *types;
 
  return this->find_variable_numbers_by_predicate
    (names,
     [&type_filter](const FEType & var_type)
     {
       return type_filter.empty() ||
              std::find(type_filter.begin(), type_filter.end(), var_type) != type_filter.end();
     });
}

References find_variable_numbers_by_predicate().

Referenced by libMesh::Nemesis_IO::write_nodal_data().

◆ find_variable_numbers_by_predicate()

std::vector< std::pair< unsigned int, unsigned int > > libMesh::EquationSystems::find_variable_numbers_by_predicate	(	std::vector< std::string > &	names,
		const std::function< bool(const FEType &)> &	type_filter
	)		const

private

Implementation detail for find_variable_numbers() variants.

Definition at line 1141 of file equation_systems.C.

{
  // This function must be run on all processors at once
  parallel_object_only();
 
  libmesh_assert (this->n_systems());
 
  // Store a copy of the valid variable names, if any. The names vector will be repopulated with any
  // valid names (or all if 'is_names_empty') in the system that passes through the type filter. If
  // the variable is a vector, its name will be decomposed into its separate components in
  // accordance with build_variable_names().
  std::vector<std::string> name_filter = names;
  bool is_names_empty = name_filter.empty();
  names.clear();
 
  // initialize convenience variables
  FEType var_type;
  std::string name;
 
  const std::vector<std::string> component_suffix = {"_x", "_y", "_z"};
  unsigned int dim = _mesh.spatial_dimension();
  libmesh_error_msg_if(dim > 3, "Invalid dim in find_variable_numbers");
 
  // Now filter through the variables in each system and store the system index and their index
  // within that system. This way, we know where to find their data even after we sort them.
  std::vector<std::pair<unsigned int, unsigned int>> var_nums;
 
  for (const auto & pr : _systems)
    {
      const System & system = *(pr.second);
 
      for (auto var : make_range(system.n_vars()))
        {
          // apply the type filter
          var_type = system.variable_type(var);
          if (!type_filter(var_type))
            continue;
 
          // apply the name filter (note that all variables pass if it is empty)
          if (FEInterface::field_type(var_type) == TYPE_VECTOR)
            {
              std::vector<std::string> component_names;
              for (unsigned int comp = 0; comp < dim; ++comp)
                {
                  name = system.variable_name(var) + component_suffix[comp];
                  if (is_names_empty ||
                      (std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end()))
                    component_names.push_back(name);
                }
 
              if (! component_names.empty())
                names.insert(names.end(), component_names.begin(), component_names.end());
              else
                continue;
            }
          else /*scalar-valued variable*/
            {
              name = system.variable_name(var);
              if (is_names_empty ||
                  (std::find(name_filter.begin(), name_filter.end(), name) != name_filter.end()))
                names.push_back(name);
              else
                continue;
            }
 
          // if the variable made it through both filters get its system indices
          var_nums.emplace_back(system.number(), var);
        }
    }
 
  // Sort the var_nums vector pairs alphabetically based on the variable name
  std::vector<unsigned int> sort_index(var_nums.size());
  std::iota(sort_index.begin(), sort_index.end(), 0);
  std::sort(sort_index.begin(), sort_index.end(),
            [&](const unsigned int & lhs, const unsigned int & rhs)
            {return this->get_system(var_nums[lhs].first).variable_name(var_nums[lhs].second) <
                    this->get_system(var_nums[rhs].first).variable_name(var_nums[rhs].second);});
 
  std::vector<std::pair<unsigned int, unsigned int>> var_nums_sorted(var_nums.size());
  for (auto i : index_range(var_nums_sorted))
    {
      var_nums_sorted[i].first = var_nums[sort_index[i]].first;
      var_nums_sorted[i].second = var_nums[sort_index[i]].second;
    }
 
  // Also sort the names vector
  std::sort(names.begin(), names.end());
 
  // Return the sorted vector pairs
  return var_nums_sorted;
}

References _mesh, _systems, dim, libMesh::FEInterface::field_type(), libMesh::index_range(), libMesh::libmesh_assert(), libMesh::make_range(), n_systems(), libMesh::System::n_vars(), libMesh::System::number(), libMesh::MeshBase::spatial_dimension(), libMesh::TYPE_VECTOR, libMesh::System::variable_name(), and libMesh::System::variable_type().

Referenced by find_elemental_data_variable_numbers(), and find_variable_numbers().

◆ 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.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

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

◆ get_info() [2/2]

std::string libMesh::EquationSystems::get_info ( ) const

virtual

Returns: A string containing information about the systems, flags, and parameters.

Definition at line 1786 of file equation_systems.C.

{
  std::ostringstream oss;
 
  unsigned int n_hidden_sys = 0;
  for (auto & pr : _systems)
    n_hidden_sys += pr.second->hide_output();
 
  oss << " EquationSystems\n"
      << "  n_systems()=" << this->n_systems()
      << (n_hidden_sys ? " (hidden: " + std::to_string(n_hidden_sys) + ")" : "")
      << "\n";
 
  // Print the info for the individual systems
  for (const auto & pr : _systems)
    if (!pr.second->hide_output())
      oss << pr.second->get_info();
 
 
  //   // Possibly print the parameters
  //   if (!this->parameters.empty())
  //     {
  //       oss << "  n_parameters()=" << this->n_parameters() << '\n';
  //       oss << "   Parameters:\n";
 
  //       for (const auto & [key, val] : _parameters)
  //         oss << "    "
  //             << "\""
  //             << key
  //             << "\""
  //             << "="
  //             << val
  //             << '\n';
  //     }
 
  return oss.str();
}

◆ get_mesh() [1/2]

MeshBase & libMesh::EquationSystems::get_mesh ( )

inline

Returns: A reference to the mesh

Definition at line 673 of file equation_systems.h.

{
  return _mesh;
}

References _mesh.

◆ get_mesh() [2/2]

const MeshBase & libMesh::EquationSystems::get_mesh ( ) const

inline

Returns: A constant reference to the mesh

Definition at line 665 of file equation_systems.h.

{
  return _mesh;
}

References _mesh.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), alternative_fe_assembly(), LinearElasticity::assemble(), assemble(), assemble(), assemble_1D(), assemble_biharmonic(), assemble_cd(), 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_poisson(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_shell(), assemble_stokes(), assemble_temperature_jump(), assemble_wave(), assemble_wave(), assembly_with_dg_fem_context(), build_variable_names(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), compute_stresses(), enable_default_ghosting(), libMesh::AdjointRefinementEstimator::estimate_error(), fe_assembly(), fill_dirichlet_bc(), libMesh::MeshFunction::init(), LargeDeformationElasticity::jacobian(), LaplaceYoung::jacobian(), periodic_bc_test_poisson(), read(), reinit_solutions(), LargeDeformationElasticity::residual(), LaplaceYoung::residual(), run_timestepping(), scale_mesh_and_plot(), libMesh::DirectSolutionTransfer::transfer(), libMesh::DTKSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), transform_mesh_and_plot(), write(), libMesh::MeshOutput< MT >::write_equation_systems(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), write_output(), write_output(), write_output(), and write_output_solvedata().

◆ get_system() [1/8]

template<typename T_sys >

T_sys & libMesh::EquationSystems::get_system ( const unsigned int num )

inline

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 754 of file equation_systems.h.

{
  libmesh_assert_less (num, this->n_systems());
 
  for (auto & pr : _systems)
    {
      auto & sys_ptr = pr.second;
      if (sys_ptr->number() == num)
        return cast_ref<T_sys &>(*sys_ptr);
    }
 
  // Error if we made it here
  libmesh_error_msg("ERROR: no system number " << num << " found!");
}

References _systems, and n_systems().

◆ get_system() [2/8]

System & libMesh::EquationSystems::get_system ( const unsigned int num )

inline

Returns: A writable reference to the system number num.

Definition at line 838 of file equation_systems.h.

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

◆ get_system() [3/8]

template<typename T_sys >

const T_sys & libMesh::EquationSystems::get_system ( const unsigned int num ) const

inline

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 735 of file equation_systems.h.

{
  libmesh_assert_less (num, this->n_systems());
 
  for (auto & pr : _systems)
    {
      const auto & sys_ptr = pr.second;
      if (sys_ptr->number() == num)
        return cast_ref<const T_sys &>(*sys_ptr);
    }
  // Error if we made it here
  libmesh_error_msg("ERROR: no system number " << num << " found!");
}

References _systems, and n_systems().

◆ get_system() [4/8]

const System & libMesh::EquationSystems::get_system ( const unsigned int num ) const

inline

Returns: A constant reference to system number num.

Definition at line 830 of file equation_systems.h.

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

◆ get_system() [5/8]

template<typename T_sys >

T_sys & libMesh::EquationSystems::get_system ( std::string_view name )

inline

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 795 of file equation_systems.h.

{
  auto pos = _systems.find(name);
 
  // Check for errors
  libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named " << name << " found!");
 
  // Attempt dynamic cast
  auto & sys_ptr = pos->second;
  return cast_ref<T_sys &>(*sys_ptr);
}

References _systems.

◆ get_system() [6/8]

System & libMesh::EquationSystems::get_system ( std::string_view name )

inline

Returns: A writable reference to the system named name.

Definition at line 822 of file equation_systems.h.

{
  return this->get_system<System>(name);
}

◆ get_system() [7/8]

template<typename T_sys >

const T_sys & libMesh::EquationSystems::get_system ( std::string_view name ) const

inline

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 776 of file equation_systems.h.

{
  auto pos = _systems.find(name);
 
  // Check for errors
  libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named \"" << name << "\" found!");
 
  // Attempt dynamic cast
  const auto & sys_ptr = pos->second;
  return cast_ref<const T_sys &>(*sys_ptr);
}

References _systems.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), add_M_C_K_helmholtz(), libMesh::EnsightIO::add_scalar(), libMesh::RBSCMConstruction::add_scaled_symm_Aq(), add_system(), libMesh::EnsightIO::add_vector(), libMesh::EnsightIO::add_vector(), adjoint_solve(), allgather(), alternative_fe_assembly(), apply_initial(), LinearElasticity::assemble(), assemble(), assemble(), assemble_1D(), assemble_biharmonic(), assemble_cd(), 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_poisson(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_shell(), assemble_stokes(), assemble_temperature_jump(), assemble_wave(), assemble_wave(), assembly_with_dg_fem_context(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), build_parallel_elemental_solution_vector(), compare(), libMesh::ExactSolution::compute_error(), LinearElasticity::compute_stresses(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), compute_stresses(), libMesh::GMVIO::copy_nodal_solution(), SolidSystem::element_time_derivative(), enable_default_ghosting(), libMesh::ExactSolution::error_norm(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), fe_assembly(), fill_dirichlet_bc(), libMesh::DTKAdapter::find_sys(), form_functionA(), form_functionB(), form_matrixA(), init(), init_cd(), SolidSystem::init_data(), init_sys(), initialize(), LargeDeformationElasticity::jacobian(), LaplaceYoung::jacobian(), line_print(), libMesh::RBSCMConstruction::load_matrix_B(), main(), libMesh::RBSCMConstruction::perform_SCM_greedy(), periodic_bc_test_poisson(), read(), MeshFunctionTest::read_variable_info_from_output_data(), reinit_mesh(), reinit_solutions(), reinit_systems(), LargeDeformationElasticity::residual(), LaplaceYoung::residual(), run_timestepping(), SolidSystem::save_initial_mesh(), sensitivity_solve(), set_initial_condition(), SolidSystem::side_time_derivative(), solve(), MixedDimensionMeshTest::testDofOrdering(), MixedDimensionRefinedMeshTest::testDofOrdering(), MixedDimensionNonUniformRefinement::testDofOrdering(), MixedDimensionNonUniformRefinementTriangle::testDofOrdering(), MixedDimensionNonUniformRefinement3D::testDofOrdering(), SlitMeshRefinedSystemTest::testRestart(), 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().

◆ get_system() [8/8]

const System & libMesh::EquationSystems::get_system ( std::string_view name ) const

inline

Returns: A constant reference to the system named name.

Definition at line 814 of file equation_systems.h.

{
  return this->get_system<System>(name);
}

◆ 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

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

Definition at line 1063 of file equation_systems.C.

{
  vars_active_subdomains.clear();
  vars_active_subdomains.resize(names.size());
 
  for (const auto & pr : _systems)
    {
      const auto & sys_ptr = pr.second;
      for (auto vn : make_range(sys_ptr->n_vars()))
        {
          const std::string & var_name = sys_ptr->variable_name(vn);
 
          auto names_it = std::find(names.begin(), names.end(), var_name);
          if(names_it != names.end())
            {
              const Variable & variable = sys_ptr->variable(vn);
              const std::set<subdomain_id_type> & active_subdomains = variable.active_subdomains();
              vars_active_subdomains[std::distance(names.begin(), names_it)] = active_subdomains;
            }
        }
    }
}

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

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

◆ has_system()

bool libMesh::EquationSystems::has_system ( std::string_view name ) const

inline

Returns: true if the system named name exists within this EquationSystems object.

Definition at line 723 of file equation_systems.h.

{
  if (_systems.find(name) == _systems.end())
    return false;
  return true;
}

References _systems.

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

◆ 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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

◆ 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.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

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

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

◆ init()

void libMesh::EquationSystems::init ( )

virtual

Initialize all the systems.

Reimplemented in Biharmonic.

Definition at line 80 of file equation_systems.C.

{
#ifndef NDEBUG
  for (auto i : make_range(this->n_systems()))
    libmesh_assert(!this->get_system(i).is_initialized());
#endif
 
  this->reinit_mesh();
}

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

◆ is_elemental_data_fe_type()

bool libMesh::EquationSystems::is_elemental_data_fe_type ( const FEType & type )

static

Returns: Whether type can be represented as elemental data.

Elemental data variables are CONSTANT element-interior fields, regardless of their p_refinement flag.

Definition at line 582 of file equation_systems.C.

{
  return type.order == CONSTANT &&
         (type.family == MONOMIAL ||
          type.family == MONOMIAL_VEC ||
          type.family == XYZ);
}

References libMesh::CONSTANT, libMesh::FEType::family, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::FEType::order, and libMesh::XYZ.

Referenced by build_elemental_data_variable_names(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), and find_elemental_data_variable_numbers().

◆ n_active_dofs()

std::size_t libMesh::EquationSystems::n_active_dofs ( ) const

Returns: The number of active degrees of freedom for the EquationSystems object.

Definition at line 1868 of file equation_systems.C.

{
  std::size_t tot=0;
 
  for (const auto & pr : _systems)
    tot += pr.second->n_active_dofs();
 
  return tot;
}

Referenced by main(), and write_output_solvedata().

◆ n_dofs()

std::size_t libMesh::EquationSystems::n_dofs ( ) const

Returns: The total number of degrees of freedom in all systems.

Definition at line 1855 of file equation_systems.C.

{
  std::size_t tot=0;
 
  for (const auto & pr : _systems)
    tot += pr.second->n_dofs();
 
  return tot;
}

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

◆ 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.

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

The number of objects.

Definition reference_counter.h:132

References libMesh::ReferenceCounter::_n_objects.

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

◆ 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.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

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

◆ n_systems()

unsigned int libMesh::EquationSystems::n_systems ( ) const

inline

Returns: The number of equation systems.

Definition at line 680 of file equation_systems.h.

{
  return cast_int<unsigned int>(_systems.size());
}

References _systems.

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

◆ n_vars()

unsigned int libMesh::EquationSystems::n_vars ( ) const

Returns: The total number of variables in all systems.

Definition at line 1843 of file equation_systems.C.

{
  unsigned int tot=0;
 
  for (const auto & pr : _systems)
    tot += pr.second->n_vars();
 
  return tot;
}

Referenced by build_variable_names().

◆ print_info() [1/2]

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

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

Definition at line 1826 of file equation_systems.C.

{
  os << this->get_info()
     << std::endl;
}

Referenced by assemble_and_solve(), do_compare(), and main().

◆ print_info() [2/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.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

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

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

◆ 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.

115 { return cast_int<processor_id_type>(_communicator.rank()); }

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

◆ read() [1/3]

template<typename InValType >

template LIBMESH_EXPORT void libMesh::EquationSystems::read< Real >	(	std::string_view	name,
		const unsigned int	read_flags = `(READ_HEADER\|READ_DATA)`,
		bool	partition_agnostic = `true`
	)

Definition at line 77 of file equation_systems_io.C.

{
  XdrMODE mode = READ;
  if (name.find(".xdr") != std::string::npos)
    mode = DECODE;
  this->read(name, mode, read_flags, partition_agnostic);
}

References libMesh::DECODE, libMesh::READ, and read().

◆ read() [2/3]

template<typename InValType >

template LIBMESH_EXPORT void libMesh::EquationSystems::read< Real >	(	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.

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

name	Name of the file to be read.
read_flags	Single flag created by bitwise-OR'ing several flags together.
mode	Controls whether reading is done in binary or ascii mode.
partition_agnostic	If 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 90 of file equation_systems_io.C.

{
  // This will unzip a file with .bz2 as the extension, otherwise it
  // simply returns the name if the file need not be unzipped.
  Xdr io ((this->processor_id() == 0) ? std::string(name) : "", mode);
 
  std::function<std::unique_ptr<Xdr>()> local_io_functor;
  local_io_functor = [this,&name,&mode]() {
    return std::make_unique<Xdr>(local_file_name(this->processor_id(), name), mode); };
 
  this->read(io, local_io_functor, read_flags, partition_agnostic);
}

References libMesh::ParallelObject::processor_id(), and read().

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

◆ read() [3/3]

template<typename InValType >

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

This program implements the input 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 109 of file equation_systems_io.C.

{
  // Set booleans from the read_flags argument
  const bool read_header          = read_flags & EquationSystems::READ_HEADER;
  const bool read_data            = read_flags & EquationSystems::READ_DATA;
  const bool read_additional_data = read_flags & EquationSystems::READ_ADDITIONAL_DATA;
  const bool read_legacy_format   = read_flags & EquationSystems::READ_LEGACY_FORMAT;
  const bool try_read_ifems       = read_flags & EquationSystems::TRY_READ_IFEMS;
  const bool read_basic_only      = read_flags & EquationSystems::READ_BASIC_ONLY;
  bool read_parallel_files  = false;
 
  std::vector<std::pair<std::string, System *>> xda_systems;
 
  libmesh_assert (io.reading());
 
  {
    // 1.)
    // Read the version header.
    std::string version = "legacy";
    if (!read_legacy_format)
      {
        if (this->processor_id() == 0) io.data(version);
        this->comm().broadcast(version);
 
        // All processors have the version header, if it does not contain
        // the libMesh_label string then it is a legacy file.
        const std::string libMesh_label = "libMesh-";
        std::string::size_type lm_pos = version.find(libMesh_label);
        if (lm_pos==std::string::npos)
          {
            io.close();
 
            // Recursively call this read() function but with the
            // EquationSystems::READ_LEGACY_FORMAT bit set.
            this->read (io, local_io_functor, (read_flags | EquationSystems::READ_LEGACY_FORMAT), partition_agnostic);
            return;
          }
 
        // Figure out the libMesh version that created this file
        std::istringstream iss(version.substr(lm_pos + libMesh_label.size()));
        int ver_major = 0, ver_minor = 0, ver_patch = 0;
        char dot;
        iss >> ver_major >> dot >> ver_minor >> dot >> ver_patch;
        io.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
 
 
        read_parallel_files = Utility::contains(version, " parallel");
 
        // If requested that we try to read infinite element information,
        // and the string " with infinite elements" is not in the version,
        // then tack it on.  This is for compatibility reading ifem
        // files written prior to 11/10/2008 - BSK
        if (try_read_ifems)
          if (!Utility::contains(version, " with infinite elements"))
            version += " with infinite elements";
 
      }
    else
      libmesh_deprecated();
 
    LOG_SCOPE("read()", "EquationSystems");
 
    // 2.)
    // Read the number of systems
    unsigned int n_sys=0;
    if (this->processor_id() == 0) io.data (n_sys);
    this->comm().broadcast(n_sys);
 
    for (unsigned int sys=0; sys<n_sys; sys++)
      {
        // 3.)
        // Read the name of the sys-th equation system
        std::string sys_name;
        if (this->processor_id() == 0) io.data (sys_name);
        this->comm().broadcast(sys_name);
 
        // 4.)
        // Read the type of the sys-th equation system
        std::string sys_type;
        if (this->processor_id() == 0) io.data (sys_type);
        this->comm().broadcast(sys_type);
 
        if (read_header)
          this->add_system (sys_type, sys_name);
 
        // 5.) - 9.)
        // Let System::read_header() do the job
        System & new_system = this->get_system(sys_name);
        new_system.read_header (io,
                                version,
                                read_header,
                                read_additional_data,
                                read_legacy_format);
 
        xda_systems.emplace_back(sys_name, &new_system);
 
        // If we're only creating "basic" systems, we need to tell
        // each system that before we call init() later.
        if (read_basic_only)
          new_system.set_basic_system_only();
      }
  }
 
 
 
  // Now we are ready to initialize the underlying data
  // structures. This will initialize the vectors for
  // storage, the dof_map, etc...
  if (read_header)
    this->init();
 
  // 10.) & 11.)
  // Read and set the numeric vector values
  if (read_data)
    {
      std::unique_ptr<Xdr> local_io;
 
      // the EquationSystems::read() method should look constant from the mesh
      // perspective, but we need to assign a temporary numbering to the nodes
      // and elements in the mesh, which requires that we abuse const_cast
      if (!read_legacy_format && partition_agnostic)
        {
          MeshBase & mesh = const_cast<MeshBase &>(this->get_mesh());
          MeshTools::Private::globally_renumber_nodes_and_elements(mesh);
        }
 
      for (auto & pr : xda_systems)
      {
        libmesh_error_msg_if(read_legacy_format,
                             "Reading legacy format XDR files is officially no longer supported.");
 
        if (read_parallel_files)
          {
            if (!local_io)
            {
              local_io = local_io_functor();
              libmesh_assert(local_io->reading());
            }
            pr.second->read_parallel_data<InValType> (*local_io, read_additional_data);
          }
        else
          pr.second->read_serialized_data<InValType> (io, read_additional_data);
      }
 
      // Undo the temporary numbering.
      if (!read_legacy_format && partition_agnostic)
        _mesh.fix_broken_node_and_element_numbering();
    }
 
  // Localize each system's data
  this->update();
 
  #ifdef LIBMESH_ENABLE_AMR
    MeshRefinement mesh_refine(_mesh);
    mesh_refine.clean_refinement_flags();
  #endif
}

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

◆ redundant_added_side()

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

static

Definition at line 1706 of file equation_systems.C.

{
  libmesh_assert(elem.active());
 
  const Elem * neigh = elem.neighbor_ptr(side);
 
  // Write boundary sides.
  if (!neigh)
    return false;
 
  // Write ghost sides in Nemesis
  if (neigh == remote_elem)
    return false;
 
  // Don't write a coarser side if a finer side exists
  if (!neigh->active())
    return true;
 
  // Don't write a side redundantly from both of the
  // elements sharing it.  We'll disambiguate with id().
  return (neigh->id() < elem.id());
}

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

Referenced by 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().

◆ refine_in_reinit_flag()

bool libMesh::EquationSystems::refine_in_reinit_flag ( )

inline

Returns: Whether or not calls to reinit() will try to coarsen/refine the mesh

Definition at line 590 of file equation_systems.h.

590{ return this->_refine_in_reinit; }

References _refine_in_reinit.

◆ reinit()

void libMesh::EquationSystems::reinit ( )

virtual

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

Definition at line 92 of file equation_systems.C.

{
  const bool mesh_changed = this->reinit_solutions();
 
  // If the mesh has changed, systems will need to reinitialize their
  // own data on the new mesh.
  if (mesh_changed)
    this->reinit_systems();
}

References reinit_solutions(), and reinit_systems().

◆ reinit_mesh()

void libMesh::EquationSystems::reinit_mesh ( )

virtual

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.

{
  const unsigned int n_sys = this->n_systems();
 
  libmesh_assert_not_equal_to (n_sys, 0);
 
  // Tell all the \p DofObject entities how many systems
  // there are.
  for (auto & node : _mesh.node_ptr_range())
    node->set_n_systems(n_sys);
 
  Threads::parallel_for
    (_mesh.element_stored_range(),
     [n_sys](const ElemRange & range)
     {
       for (Elem * elem : range)
         elem->set_n_systems(n_sys);
     });
 
  //for (auto i : make_range(this->n_systems()))
    //this->get_system(i).init();
 
#ifdef LIBMESH_ENABLE_AMR
  MeshRefinement mesh_refine(_mesh);
  mesh_refine.clean_refinement_flags();
#endif
 
 // Now loop over all the systems belonging to this ES
 // and call reinit_mesh for each system
 for (auto i : make_range(this->n_systems()))
    this->get_system(i).reinit_mesh();
 
}

References _mesh, libMesh::MeshRefinement::clean_refinement_flags(), libMesh::MeshBase::element_stored_range(), get_system(), libMesh::make_range(), n_systems(), and libMesh::Threads::parallel_for().

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

◆ reinit_solutions()

bool libMesh::EquationSystems::reinit_solutions ( )

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

Returns: Whether or not the mesh may have changed.

Definition at line 136 of file equation_systems.C.

{
  parallel_object_only();
 
  const unsigned int n_sys = this->n_systems();
  libmesh_assert_not_equal_to (n_sys, 0);
 
  // And any new systems will need initialization
  for (unsigned int i=0; i != n_sys; ++i)
    if (!this->get_system(i).is_initialized())
      this->get_system(i).init();
 
  // We used to assert that all nodes and elements *already* had
  // n_systems() properly set; however this is false in the case where
  // user code has manually added nodes and/or elements to an
  // already-initialized system.
 
  // Make sure all the \p DofObject entities know how many systems
  // there are.
  {
    // All the nodes
    for (auto & node : _mesh.node_ptr_range())
      node->set_n_systems(n_sys);
 
    // All the elements
    Threads::parallel_for
      (_mesh.element_stored_range(),
       [n_sys](const ElemRange & range)
       {
         for (Elem * elem : range)
           elem->set_n_systems(n_sys);
       });
  }
 
  // Localize each system's vectors
  for (unsigned int i=0; i != n_sys; ++i)
    this->get_system(i).re_update();
 
#ifdef LIBMESH_ENABLE_AMR
 
  bool mesh_changed = false;
 
  // FIXME: For backwards compatibility, assume
  // refine_and_coarsen_elements or refine_uniformly have already
  // been called
  {
    for (unsigned int i=0; i != n_sys; ++i)
      {
        System & sys = this->get_system(i);
 
        // Even if the system doesn't have any variables in it we want
        // consistent behavior; e.g. distribute_dofs should have the
        // opportunity to count up zero dofs on each processor.
        //
        // Who's been adding zero-var systems anyway, outside of my
        // unit tests? - RHS
        // if (!sys.n_vars())
        // continue;
 
        sys.get_dof_map().distribute_dofs(_mesh);
 
        // Recreate any user or internal constraints
        sys.reinit_constraints();
 
        // Even if there weren't any constraint changes,
        // reinit_constraints() did prepare_send_list() for us.
 
        sys.prolong_vectors();
      }
    mesh_changed = true;
  }
 
  if (this->_refine_in_reinit)
    {
      // Don't override any user refinement settings
      MeshRefinement mesh_refine(_mesh);
      mesh_refine.face_level_mismatch_limit() = 0; // unlimited
      mesh_refine.overrefined_boundary_limit() = -1; // unlimited
      mesh_refine.underrefined_boundary_limit() = -1; // unlimited
 
      // Try to coarsen the mesh, then restrict each system's vectors
      // if necessary
      if (mesh_refine.coarsen_elements())
        {
          for (auto i : make_range(this->n_systems()))
            {
              System & sys = this->get_system(i);
              sys.get_dof_map().distribute_dofs(_mesh);
              sys.reinit_constraints();
 
              // Even if there weren't any constraint changes,
              // reinit_constraints() did prepare_send_list() for us.
 
              sys.restrict_vectors();
            }
          mesh_changed = true;
        }
 
      // Once vectors are all restricted, we can delete
      // children of coarsened elements
      if (mesh_changed)
        this->get_mesh().contract();
 
      // Try to refine the mesh, then prolong each system's vectors
      // if necessary
      if (mesh_refine.refine_elements())
        {
          for (auto i : make_range(this->n_systems()))
            {
              System & sys = this->get_system(i);
              sys.get_dof_map().distribute_dofs(_mesh);
              sys.reinit_constraints();
 
              // Even if there weren't any constraint changes,
              // reinit_constraints() did prepare_send_list() for us.
 
              sys.prolong_vectors();
            }
          mesh_changed = true;
        }
    }
 
  return mesh_changed;
 
#endif // #ifdef LIBMESH_ENABLE_AMR
 
  return false;
}

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

Referenced by reinit().

◆ reinit_systems()

void libMesh::EquationSystems::reinit_systems ( )

virtual

Reinitialize all systems on the current mesh.

Definition at line 267 of file equation_systems.C.

{
  for (auto i : make_range(this->n_systems()))
    this->get_system(i).reinit();
}

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

Referenced by reinit().

◆ sensitivity_solve()

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

virtual

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 445 of file equation_systems.C.

{
  libmesh_assert (this->n_systems());
 
  for (auto i : make_range(this->n_systems()))
    this->get_system(i).sensitivity_solve(parameters_in);
}

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

◆ solve()

void libMesh::EquationSystems::solve ( )

virtual

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 435 of file equation_systems.C.

{
  libmesh_assert (this->n_systems());
 
  for (auto i : make_range(this->n_systems()))
    this->get_system(i).solve();
}

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

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

◆ update()

void libMesh::EquationSystems::update ( )

Updates local values for all the systems.

Definition at line 342 of file equation_systems.C.

{
  LOG_SCOPE("update()", "EquationSystems");
 
  // Localize each system's vectors
  for (auto i : make_range(this->n_systems()))
    this->get_system(i).update();
}

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

Referenced by main(), read(), and MeshFunctionTest::read_variable_info_from_output_data().

◆ write() [1/4]

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

◆ write() [2/4]

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

Definition at line 335 of file equation_systems_io.C.

{
  XdrMODE mode = WRITE;
  if (name.find(".xdr") != std::string::npos)
    mode = ENCODE;
  this->write(name, mode, write_flags, partition_agnostic);
}

References libMesh::ENCODE, libMesh::WRITE, and write().

◆ write() [3/4]

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

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

name	Name of the file to be read.
write_flags	Single flag created by bitwise-OR'ing several flags together.
mode	Controls whether reading is done in binary or ascii mode.
partition_agnostic	If 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 347 of file equation_systems_io.C.

{
  Xdr io((this->processor_id()==0) ? std::string(name) : "", mode);
 
  std::unique_ptr<Xdr> local_io;
  // open a parallel buffer if warranted
  if (write_flags & EquationSystems::WRITE_PARALLEL_FILES && write_flags & EquationSystems::WRITE_DATA)
    local_io = std::make_unique<Xdr>(local_file_name(this->processor_id(),name), mode);
 
  this->write(io, write_flags, partition_agnostic, local_io.get());
}

References libMesh::ParallelObject::processor_id(), write(), WRITE_DATA, and 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(), write(), write(), libMesh::NameBasedIO::write_equation_systems(), and write_output().

◆ 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

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 364 of file equation_systems_io.C.

{
  // the EquationSystems::write() method should look constant,
  // but we need to assign a temporary numbering to the nodes
  // and elements in the mesh, which requires that we abuse const_cast
  if (partition_agnostic)
    {
      MeshBase & mesh = const_cast<MeshBase &>(this->get_mesh());
      MeshTools::Private::globally_renumber_nodes_and_elements(mesh);
    }
 
  // set booleans from write_flags argument
  const bool write_data            = write_flags & EquationSystems::WRITE_DATA;
  const bool write_additional_data = write_flags & EquationSystems::WRITE_ADDITIONAL_DATA;
 
  // always write parallel files if we're instructed to write in
  // parallel
  const bool write_parallel_files  =
    (write_flags & EquationSystems::WRITE_PARALLEL_FILES)
    // Even if we're on a distributed mesh, we may or may not have a
    // consistent way of reconstructing the same mesh partitioning
    // later, but we need the same mesh partitioning if we want to
    // reread the parallel solution safely, so let's write a serial file
    // unless specifically requested not to.
    // ||
    // // but also write parallel files if we haven't been instructed to
    // // write in serial and we're on a distributed mesh
    // (!(write_flags & EquationSystems::WRITE_SERIAL_FILES) &&
    // !this->get_mesh().is_serial())
    ;
 
  if (write_parallel_files && write_data)
    libmesh_assert(local_io);
 
  {
    libmesh_assert (io.writing());
 
    LOG_SCOPE("write()", "EquationSystems");
 
    const unsigned int proc_id = this->processor_id();
 
    unsigned int n_sys = 0;
    for (auto & pr : _systems)
      if (!pr.second->hide_output())
        n_sys++;
 
    // set the version number in the Xdr object
    io.set_version(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION,
                                      LIBMESH_MINOR_VERSION,
                                      LIBMESH_MICRO_VERSION));
 
    // Only write the header information
    // if we are processor 0.
    if (proc_id == 0)
      {
        std::string comment;
 
        // 1.)
        // Write the version header
        std::string version("libMesh-" + libMesh::get_io_compatibility_version());
        if (write_parallel_files) version += " parallel";
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
        version += " with infinite elements";
#endif
        io.data (version, "# File Format Identifier");
 
        // 2.)
        // Write the number of equation systems
        io.data (n_sys, "# No. of Equation Systems");
 
        for (auto & [sys_name, sys] : _systems)
          {
            // Ignore this system if it has been marked as hidden
            if (sys->hide_output()) continue;
 
            // 3.)
            // Write the name of the sys_num-th system
            {
              const unsigned int sys_num = sys->number();
 
              comment =  "# Name, System No. ";
              comment += std::to_string(sys_num);
 
              // Note: There is no Xdr::data overload taking a "const
              // std::string &" so we need to make a copy.
              std::string copy = sys_name;
              io.data (copy, comment);
            }
 
            // 4.)
            // Write the type of system handled
            {
              const unsigned int sys_num = sys->number();
              std::string sys_type       = sys->system_type();
 
              comment =  "# Type, System No. ";
              comment += std::to_string(sys_num);
 
              io.data (sys_type, comment);
            }
 
            // 5.) - 9.)
            // Let System::write_header() do the job
            sys->write_header (io, version, write_additional_data);
          }
      }
 
    // Start from the first system, again,
    // to write vectors to disk, if wanted
    if (write_data)
      {
        for (auto & pr : _systems)
          {
            // Ignore this system if it has been marked as hidden
            if (pr.second->hide_output()) continue;
 
            // 10.) + 11.)
            if (write_parallel_files)
              pr.second->write_parallel_data (*local_io,write_additional_data);
            else
              pr.second->write_serialized_data (io,write_additional_data);
          }
 
        if (local_io)
          local_io->close();
      }
 
    io.close();
  }
 
  // the EquationSystems::write() method should look constant,
  // but we need to undo the temporary numbering of the nodes
  // and elements in the mesh, which requires that we abuse const_cast
  if (partition_agnostic)
    const_cast<MeshBase &>(_mesh).fix_broken_node_and_element_numbering();
}

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

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const EquationSystems &	es
	)

friend

Same as above, but allows you to also use stream syntax.

Definition at line 1834 of file equation_systems.C.

{
  es.print_info(os);
  return os;
}

Member Data Documentation

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by build_parallel_elemental_solution_vector(), 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(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

◆ _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().

◆ _enable_default_ghosting

bool libMesh::EquationSystems::_enable_default_ghosting

protected

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

Default value: true

Definition at line 634 of file equation_systems.h.

Referenced by add_system(), and 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().

◆ _mesh

MeshBase& libMesh::EquationSystems::_mesh

protected

The mesh data structure.

Definition at line 617 of file equation_systems.h.

Referenced by allgather(), build_elemental_data_variable_names(), build_parallel_elemental_solution_vector(), build_parallel_solution_vector(), find_variable_numbers_by_predicate(), get_mesh(), get_mesh(), read(), reinit_mesh(), reinit_solutions(), and write().

◆ _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_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(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _refine_in_reinit

bool libMesh::EquationSystems::_refine_in_reinit

protected

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

Default value: true

Definition at line 628 of file equation_systems.h.

Referenced by disable_refine_in_reinit(), enable_refine_in_reinit(), refine_in_reinit_flag(), and reinit_solutions().

◆ _systems

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

protected

Data structure holding the systems.

Definition at line 622 of file equation_systems.h.

Referenced by add_system(), add_system(), build_elemental_data_variable_names(), build_parallel_solution_vector(), build_variable_names(), clear(), find_variable_numbers_by_predicate(), get_system(), get_system(), get_system(), get_system(), get_vars_active_subdomains(), has_system(), n_systems(), and write().

◆ parameters

Parameters libMesh::EquationSystems::parameters

Data structure holding arbitrary parameters.

Definition at line 608 of file equation_systems.h.

Referenced by add_M_C_K_helmholtz(), assemble_biharmonic(), assemble_cd(), assemble_cd(), assemble_divgrad(), assemble_ellipticdg(), assemble_func(), assemble_helmholtz(), assemble_poisson(), assemble_SchroedingerEquation(), assemble_shell(), assemble_shell(), assemble_stokes(), assemble_wave(), assemble_wave(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), clear(), libMesh::NewmarkSystem::clear(), libMesh::FrequencySystem::clear_all(), compute_jacobian(), compute_residual(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), 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(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ProjectSolutionTest::test_partial_project_solution(), 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:

include/systems/equation_systems.h
src/systems/equation_systems.C
src/systems/equation_systems_io.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ Counts

Member Enumeration Documentation

◆ ReadFlags

◆ WriteFlags

Constructor & Destructor Documentation

◆ EquationSystems()

◆ ~EquationSystems()

Member Function Documentation

◆ _add_system_to_nodes_and_elems()

◆ _remove_default_ghosting()

◆ add_system() [1/2]

◆ add_system() [2/2]

◆ adjoint_solve()

◆ allgather()

◆ build_discontinuous_solution_vector()

◆ build_elemental_data_variable_names()

◆ build_elemental_solution_vector()

◆ build_parallel_elemental_solution_vector()

◆ build_parallel_solution_vector()

◆ build_solution_vector() [1/2]

◆ build_solution_vector() [2/2]

◆ build_variable_names()

◆ clear()

◆ comm()

◆ compare()

◆ disable_print_counter_info()

◆ disable_refine_in_reinit()

◆ enable_default_ghosting()

◆ enable_print_counter_info()

◆ enable_refine_in_reinit()

◆ find_elemental_data_variable_numbers()

◆ find_variable_numbers()

◆ find_variable_numbers_by_predicate()

◆ get_info() [1/2]

◆ get_info() [2/2]

◆ get_mesh() [1/2]

◆ get_mesh() [2/2]

◆ get_system() [1/8]

◆ get_system() [2/8]

◆ get_system() [3/8]

◆ get_system() [4/8]

◆ get_system() [5/8]

◆ get_system() [6/8]

◆ get_system() [7/8]

◆ get_system() [8/8]

◆ get_vars_active_subdomains()

◆ has_system()

◆ increment_constructor_count()

◆ increment_destructor_count()

◆ init()

◆ is_elemental_data_fe_type()

◆ n_active_dofs()

◆ n_dofs()

◆ n_objects()

◆ n_processors()

◆ n_systems()

◆ n_vars()

◆ print_info() [1/2]

◆ print_info() [2/2]

◆ processor_id()

◆ read() [1/3]

◆ read() [2/3]

◆ read() [3/3]

◆ redundant_added_side()

◆ refine_in_reinit_flag()

◆ reinit()

◆ reinit_mesh()

◆ reinit_solutions()