Manages multiples systems of equations. 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 }

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

Public Member Functions
	EquationSystems (MeshBase &mesh)

virtual	~EquationSystems ()

virtual void	clear ()

virtual void	init ()

virtual void	reinit ()

virtual void	enable_default_ghosting (bool enable)

void	update ()

unsigned int	n_systems () const

bool	has_system (const std::string &name) const

template<typename T_sys >
const T_sys &	get_system (const std::string &name) const

template<typename T_sys >
T_sys &	get_system (const std::string &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 (const std::string &name) const

System &	get_system (const std::string &name)

const System &	get_system (const unsigned int num) const

System &	get_system (const unsigned int num)

virtual System &	add_system (const std::string &system_type, const std::string &name)

template<typename T_sys >
T_sys &	add_system (const std::string &name)

void	delete_system (const std::string &name)

unsigned int	n_vars () const

std::size_t	n_dofs () const

std::size_t	n_active_dofs () const

virtual void	solve ()

virtual void	adjoint_solve (const QoISet &qoi_indices=QoISet())

virtual void	sensitivity_solve (const ParameterVector &parameters)

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

void	build_solution_vector (std::vector< Number > &soln, const std::string &system_name, const std::string &variable_name="all_vars") const

void	build_solution_vector (std::vector< Number > &soln, const std::set< std::string > *system_names=nullptr) const

std::unique_ptr< NumericVector< Number > >	build_parallel_solution_vector (const std::set< std::string > *system_names=nullptr) const

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

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

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

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

void	build_discontinuous_solution_vector (std::vector< Number > &soln, const std::set< std::string > *system_names=nullptr) const

template<typename InValType >
void	read (const std::string &name, const XdrMODE, const unsigned int read_flags=(READ_HEADER\|READ_DATA), bool partition_agnostic=true)

void	read (const std::string &name, const XdrMODE mode, const unsigned int read_flags=(READ_HEADER\|READ_DATA), bool partition_agnostic=true)

template<typename InValType >
void	read (const std::string &name, const unsigned int read_flags=(READ_HEADER\|READ_DATA), bool partition_agnostic=true)

void	read (const std::string &name, const unsigned int read_flags=(READ_HEADER\|READ_DATA), bool partition_agnostic=true)

void	write (const std::string &name, const XdrMODE, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const

void	write (const std::string &name, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) 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

const MeshBase &	get_mesh () const

MeshBase &	get_mesh ()

void	allgather ()

void	enable_refine_in_reinit ()

void	disable_refine_in_reinit ()

bool	refine_in_reinit_flag ()

bool	reinit_solutions ()

virtual void	reinit_systems ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static std::string	get_info ()

static void	print_info (std::ostream &out=libMesh::out)

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Public Attributes
Parameters	parameters

Protected Types
typedef std::map< std::string, System * >::iterator	system_iterator

typedef std::map< std::string, System * >::const_iterator	const_system_iterator

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

Protected Member Functions
void	increment_constructor_count (const std::string &name)

void	increment_destructor_count (const std::string &name)

Protected Attributes
MeshBase &	_mesh

std::map< std::string, System * >	_systems

bool	_refine_in_reinit

bool	_enable_default_ghosting

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter = true

Private Member Functions
template<typename InValType >
void	_read_impl (const std::string &name, const XdrMODE, const unsigned int read_flags, bool partition_agnostic=true)

void	_add_system_to_nodes_and_elems ()

void	_remove_default_ghosting (unsigned int sys_num)

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

Detailed Description

Manages multiples systems of equations.

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

Definition at line 74 of file equation_systems.h.

Member Typedef Documentation

◆ const_system_iterator

typedef std::map<std::string, System *>::const_iterator libMesh::EquationSystems::const_system_iterator

protected

Typedef for constant system iterators

Definition at line 566 of file equation_systems.h.

◆ 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 117 of file reference_counter.h.

◆ system_iterator

typedef std::map<std::string, System *>::iterator libMesh::EquationSystems::system_iterator

protected

Typedef for system iterators

Definition at line 561 of file equation_systems.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 83 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 93 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 55 of file equation_systems.C.

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

                                               :
   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;
 }

◆ ~EquationSystems()

libMesh::EquationSystems::~EquationSystems ( )

virtual

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

Definition at line 68 of file equation_systems.C.

References clear().

 {
   this->clear ();
 }

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

References _mesh, libMesh::MeshBase::element_ptr_range(), and libMesh::MeshBase::node_ptr_range().

Referenced by add_system().

 {
   // All the nodes
   for (auto & node : _mesh.node_ptr_range())
     node->add_system();
 
   // All the elements
   for (auto & elem : _mesh.element_ptr_range())
     elem->add_system();
 }

◆ _read_impl()

template<typename InValType >

template void libMesh::EquationSystems::_read_impl< Real >	(	const std::string &	name,
		const XdrMODE	,
		const unsigned int	read_flags,
		bool	partition_agnostic = `true`
	)

private

Actual read implementation. This can be called repeatedly inside a try-catch block in an attempt to read broken files.

Parameters

name	Name of the file to be read.
read_flags	Single flag created by bitwise-OR'ing several flags together.
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.

Note: This renumbering is not compatible with meshes that have two nodes in exactly the same position!

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

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

for each system

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

handled through System::read():

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

end system loop


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

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

end system loop

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

Definition at line 143 of file equation_systems_io.C.

References _mesh, add_system(), libMesh::Parallel::Communicator::broadcast(), libMesh::Xdr::close(), libMesh::ParallelObject::comm(), libMesh::Xdr::data(), libMesh::MeshBase::fix_broken_node_and_element_numbering(), get_mesh(), get_system(), libMesh::MeshTools::Private::globally_renumber_nodes_and_elements(), init(), 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().

 {
   // 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;
 
   // 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) ? name : "", mode);
   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 (name, mode, (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 = (version.rfind(" parallel") < version.size());
 
         // 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 (!(version.rfind(" with infinite elements") < version.size()))
             version += " with infinite elements";
 
       }
     else
       libmesh_deprecated();
 
     START_LOG("read()","EquationSystems");
 
     // 2.)
     // Read the number of equation 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.push_back(std::make_pair(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)
     {
       // 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);
         }
 
       Xdr local_io (read_parallel_files ? local_file_name(this->processor_id(),name) : "", mode);
 
       for (auto & pr : xda_systems)
         if (read_legacy_format)
           {
             libmesh_deprecated();
 #ifdef LIBMESH_ENABLE_DEPRECATED
             pr.second->read_legacy_data (io, read_additional_data);
 #endif
           }
         else
           if (read_parallel_files)
             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();
     }
 
   STOP_LOG("read()","EquationSystems");
 
   // Localize each system's data
   this->update();
 }

◆ _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 1352 of file equation_systems.C.

References get_system().

Referenced by add_system().

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

◆ add_system() [1/2]

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

virtual

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

Definition at line 355 of file equation_systems.C.

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

Referenced by _read_impl(), and libMesh::ErrorVector::plot_error().

 {
   // 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);
 }

◆ add_system() [2/2]

template<typename T_sys >

T_sys & libMesh::EquationSystems::add_system ( const std::string & name )

inline

Add the system named name to the systems array.

Definition at line 647 of file equation_systems.h.

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

 {
   T_sys * ptr = nullptr;
 
   if (!_systems.count(name))
     {
       const unsigned int sys_num = this->n_systems();
       ptr = new T_sys(*this, name, sys_num);
 
       _systems.insert (std::make_pair(name, ptr));
 
       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();
     }
   else
     {
       // We now allow redundant add_system calls, to make it
       // easier to load data from files for user-derived system
       // subclasses
       ptr = &(this->get_system<T_sys>(name));
     }
 
   // Return a dynamically casted reference to the newly added System.
   return *ptr;
 }

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

References get_system(), and n_systems().

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

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

◆ allgather()

void libMesh::EquationSystems::allgather ( )

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

Definition at line 284 of file equation_systems.C.

References _mesh, libMesh::MeshBase::allgather(), libMesh::DofMap::distribute_dofs(), libMesh::MeshBase::element_ptr_range(), libMesh::System::get_dof_map(), get_system(), libMesh::MeshBase::is_serial(), n_systems(), libMesh::MeshBase::node_ptr_range(), libMesh::DofMap::prepare_send_list(), and libMesh::System::reinit_constraints().

 {
   // 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);
 
   for (auto & elem : _mesh.element_ptr_range())
     elem->set_n_systems(n_sys);
 
   // And distribute each system's dofs
   for (unsigned int i=0; i != this->n_systems(); ++i)
     {
       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();
       dof_map.prepare_send_list();
     }
 }

◆ build_discontinuous_solution_vector()

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

Fill the input vector soln with solution values. The entries will be in variable-major format (corresponding to the names from build_variable_names()). If systems_names!=nullptr, only include data from the specified systems.

Definition at line 1055 of file equation_systems.C.

References _mesh, _systems, libMesh::MeshBase::active_element_ptr_range(), libMesh::Variable::active_on_subdomain(), libMesh::DofMap::dof_indices(), end, libMesh::System::get_dof_map(), libMesh::MeshBase::mesh_dimension(), n_systems(), libMesh::System::n_vars(), libMesh::FEInterface::nodal_soln(), libMesh::ParallelObject::processor_id(), libMesh::System::update_global_solution(), libMesh::System::variable(), and libMesh::System::variable_type().

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

 {
   LOG_SCOPE("build_discontinuous_solution_vector()", "EquationSystems");
 
   libmesh_assert (this->n_systems());
 
   const unsigned int dim = _mesh.mesh_dimension();
 
   // Get the number of variables (nv) by counting the number of variables
   // in each system listed in system_names
   unsigned int nv = 0;
 
   {
     const_system_iterator       pos = _systems.begin();
     const const_system_iterator end = _systems.end();
 
     for (; pos != end; ++pos)
       {
         // 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(pos->first);
         if (!use_current_system || pos->second->hide_output())
           continue;
 
         const System & system  = *(pos->second);
         nv += system.n_vars();
       }
   }
 
   unsigned int tw=0;
 
   // get the total weight
   for (const auto & elem : _mesh.active_element_ptr_range())
     tw += elem->n_nodes();
 
   // 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;
 
 
   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.
   {
     const_system_iterator       pos = _systems.begin();
     const const_system_iterator end = _systems.end();
 
     for (; pos != end; ++pos)
       {
         // 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(pos->first);
         if (!use_current_system || pos->second->hide_output())
           continue;
 
         const System & system  = *(pos->second);
         const unsigned int nv_sys = system.n_vars();
 
         system.update_global_solution (sys_soln, 0);
 
         if (_mesh.processor_id() == 0)
           {
             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
 
             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 nn=0;
 
                 for (auto & elem : _mesh.active_element_ptr_range())
                   {
                     if (var_description.active_on_subdomain(elem->subdomain_id()))
                     {
                       system.get_dof_map().dof_indices (elem, dof_indices, var);
 
                       elem_soln.resize(dof_indices.size());
 
                       for (std::size_t i=0; i<dof_indices.size(); i++)
                         elem_soln[i] = sys_soln[dof_indices[i]];
 
                       FEInterface::nodal_soln (dim,
                                                fe_type,
                                                elem,
                                                elem_soln,
                                                nodal_soln);
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                       // infinite elements should be skipped...
                       if (!elem->infinite())
 #endif
                       {
                         libmesh_assert_equal_to (nodal_soln.size(), elem->n_nodes());
 
                         for (unsigned int n=0; n<elem->n_nodes(); n++)
                         {
                           soln[nv*(nn++) + (var + var_num)] +=
                             nodal_soln[n];
                         }
                       }
                     }
                     else
                       nn += elem->n_nodes();
                   }
               }
           }
 
         var_num += nv_sys;
       }
   }
 }

◆ 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 CONSTANT MONOMIALs. 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 893 of file equation_systems.C.

References build_parallel_elemental_solution_vector().

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

 {
   // 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 CONSTANT, MONOMIAL variables or there were
   // simply no CONSTANT, MONOMIAL variables in the EquationSystems
   // object.
   soln.clear();
   if (parallel_soln)
     parallel_soln->localize_to_one(soln);
 }

◆ 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 CONSTANT MONOMIAL solution values corresponding to the entries in the input 'names' vector. This vector is approximately uniformly distributed across all of the available processors.

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

Returns: A nullptr (if no CONSTANT, MONOMIAL variables exist on the system) or a std::unique_ptr to a var-major numeric vector of total length n_elem * n_vars ordered according to: [u0, u1, ... uN, v0, v1, ... vN, w0, w1, ... wN] for constant monomial variables (u, v, w) on a mesh with N elements.

Definition at line 913 of file equation_systems.C.

References libMesh::ParallelObject::_communicator, _mesh, _systems, libMesh::MeshBase::active_local_element_ptr_range(), libMesh::Variable::active_on_subdomain(), libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::ParallelObject::comm(), libMesh::CONSTANT, libMesh::System::current_local_solution, libMesh::DofMap::dof_indices(), end, libMesh::System::get_dof_map(), libMesh::NumericVector< T >::init(), libMesh::MeshBase::max_elem_id(), libMesh::MONOMIAL, libMesh::MeshBase::n_elem(), libMesh::ParallelObject::n_processors(), n_systems(), libMesh::System::n_vars(), libMesh::PARALLEL, libMesh::ParallelObject::processor_id(), libMesh::NumericVector< T >::set(), libMesh::System::solution, libMesh::System::update(), libMesh::System::variable(), libMesh::System::variable_name(), and libMesh::System::variable_type().

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

 {
   // This function must be run on all processors at once
   parallel_object_only();
 
   libmesh_assert (this->n_systems());
 
   const dof_id_type ne = _mesh.n_elem();
 
   libmesh_assert_equal_to (ne, _mesh.max_elem_id());
 
   // If the names vector has entries, we will only populate the soln vector
   // with names included in that list.  Note: The names vector may be
   // reordered upon exiting this function
   std::vector<std::string> filter_names = names;
   bool is_filter_names = !filter_names.empty();
 
   names.clear();
 
   const FEType type(CONSTANT, MONOMIAL);
 
   dof_id_type nv = 0;
 
   // Find the total number of variables to output
   std::vector<std::vector<unsigned>> do_output(_systems.size());
   {
     const_system_iterator       pos = _systems.begin();
     const const_system_iterator end = _systems.end();
     unsigned sys_ctr = 0;
 
     for (; pos != end; ++pos, ++sys_ctr)
       {
         const System & system = *(pos->second);
         const unsigned int nv_sys = system.n_vars();
 
         do_output[sys_ctr].resize(nv_sys);
 
         for (unsigned int var=0; var < nv_sys; ++var)
           {
             if (system.variable_type(var) != type ||
                 (is_filter_names && std::find(filter_names.begin(), filter_names.end(), system.variable_name(var)) == filter_names.end()))
               continue;
 
             // Otherwise, this variable should be output
             nv++;
             do_output[sys_ctr][var] = 1;
           }
       }
   }
 
   // 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);
 
   dof_id_type var_num = 0;
 
   // For each system in this EquationSystems object,
   // update the global solution and collect the
   // CONSTANT MONOMIALs.  The entries are in variable-major
   // format.
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
   unsigned sys_ctr = 0;
 
   for (; pos != end; ++pos, ++sys_ctr)
     {
       const System & system  = *(pos->second);
       const unsigned int nv_sys = system.n_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 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);
 
       // The DOF indices for the finite element
       std::vector<dof_id_type> dof_indices;
 
       // Loop over the variable names and load them in order
       for (unsigned int var=0; var < nv_sys; ++var)
         {
           // Skip this variable if we are not outputting it.
           if (!do_output[sys_ctr][var])
             continue;
 
           names.push_back(system.variable_name(var));
 
           const Variable & variable = system.variable(var);
           const DofMap & dof_map = system.get_dof_map();
 
           for (const auto & elem : _mesh.active_local_element_ptr_range())
             if (variable.active_on_subdomain(elem->subdomain_id()))
               {
                 dof_map.dof_indices (elem, dof_indices, var);
 
                 libmesh_assert_equal_to (1, dof_indices.size());
 
                 parallel_soln.set((ne*var_num)+elem->id(), sys_soln(dof_indices[0]));
               }
 
           var_num++;
         } // end loop on variables in this system
     } // end loop over systems
 
   parallel_soln.close();
   return std::unique_ptr<NumericVector<Number>>(parallel_soln_ptr.release());
 }

◆ build_parallel_solution_vector()

std::unique_ptr< NumericVector< Number > > libMesh::EquationSystems::build_parallel_solution_vector ( const std::set< std::string > * system_names = nullptr ) 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 600 of file equation_systems.C.

References libMesh::ParallelObject::_communicator, _mesh, _systems, std::abs(), libMesh::MeshBase::active_local_element_ptr_range(), libMesh::Variable::active_on_subdomain(), libMesh::NumericVector< T >::add(), libMesh::NumericVector< T >::build(), libMesh::NumericVector< T >::close(), libMesh::ParallelObject::comm(), libMesh::System::current_local_solution, libMesh::DofMap::dof_indices(), end, libMesh::FEInterface::field_type(), libMesh::NumericVector< T >::first_local_index(), libMesh::System::get_dof_map(), libMesh::NumericVector< T >::init(), libMesh::NumericVector< T >::last_local_index(), libMesh::MeshBase::local_nodes_begin(), libMesh::MeshBase::local_nodes_end(), libMesh::MeshBase::max_node_id(), libMesh::MeshBase::mesh_dimension(), libMesh::System::n_vars(), libMesh::FEInterface::n_vec_dim(), libMesh::FEInterface::nodal_soln(), libMesh::System::number(), libMesh::PARALLEL, libMesh::Parallel::Communicator::rank(), libMesh::NumericVector< T >::set(), libMesh::Parallel::Communicator::size(), libMesh::System::solution, libMesh::Parallel::Communicator::sum(), libMesh::TOLERANCE, libMesh::TYPE_VECTOR, libMesh::System::update(), libMesh::System::variable(), and libMesh::System::variable_type().

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

 {
   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.mesh_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;
     const_system_iterator       pos = _systems.begin();
     const const_system_iterator end = _systems.end();
 
     for (; pos != end; ++pos)
       {
         // 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(pos->first);
         if (!use_current_system || pos->second->hide_output())
           continue;
 
         for (unsigned int vn=0; vn<pos->second->n_vars(); vn++)
           {
             if (FEInterface::field_type(pos->second->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 dimension. Will break for mixed dimension meshes.
     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 dof_id_type n_gaps = max_nn - n_total_nodes;
   const dof_id_type gaps_per_processor = n_gaps / _mesh.comm().size();
   const dof_id_type remainder_gaps = n_gaps % _mesh.comm().size();
 
   n_local_nodes = n_local_nodes +      // Actual nodes
                   gaps_per_processor + // Our even share of gaps
                   (_mesh.comm().rank() < remainder_gaps); // Leftovers
 
   // 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(max_nn*nv, n_local_nodes*nv, 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(max_nn*nv, n_local_nodes*nv, 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.
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     {
       // 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(pos->first);
       if (!use_current_system || pos->second->hide_output())
         continue;
 
       const System & system  = *(pos->second);
       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 (unsigned int vn=0; vn<pos->second->n_vars(); vn++)
         {
           if (FEInterface::field_type(pos->second->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 dimension. Will break for mixed dimension meshes.
       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);
 
       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);
           const DofMap & dof_map           = system.get_dof_map();
 
           unsigned int n_vec_dim = FEInterface::n_vec_dim( pos->second->get_mesh(), fe_type );
 
           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);
 
                   elem_soln.resize(dof_indices.size());
 
                   for (std::size_t i=0; i<dof_indices.size(); i++)
                     elem_soln[i] = sys_soln(dof_indices[i]);
 
                   FEInterface::nodal_soln (dim,
                                            fe_type,
                                            elem,
                                            elem_soln,
                                            nodal_soln);
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                   // infinite elements should be skipped...
                   if (!elem->infinite())
 #endif
                     {
                       libmesh_assert_equal_to (nodal_soln.size(), n_vec_dim*elem->n_nodes());
 
                       for (unsigned int n=0; n<elem->n_nodes(); n++)
                         {
                           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(nv*(elem->node_id(n)) + (var_inc+d + var_num), nodal_soln[n_vec_dim*n+d]);
 
                               // Increment the repeat count for this position
                               repeat_count.add(nv*(elem->node_id(n)) + (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 (unsigned int n=0; n<elem->n_nodes(); n++)
                   // Only do this if this variable has NO DoFs at this node... it might have some from an adjoining element...
                   if (!elem->node_ptr(n)->n_dofs(sys_num, var))
                     for (unsigned int d=0; d < n_vec_dim; d++)
                       repeat_count.add(nv*(elem->node_id(n)) + (var+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 std::unique_ptr<NumericVector<Number>>(parallel_soln_ptr.release());
 }

◆ build_solution_vector() [1/2]

void libMesh::EquationSystems::build_solution_vector	(	std::vector< Number > &	soln,
		const std::string &	system_name,
		const std::string &	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 588 of file equation_systems.C.

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

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

◆ build_solution_vector() [2/2]

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

Fill the input vector soln with solution values. The entries will be in variable-major format (corresponding to the names from build_variable_names()). If systems_names!=nullptr, only include data from the specified systems.

Definition at line 836 of file equation_systems.C.

References build_parallel_solution_vector().

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

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

References _systems, end, libMesh::FEInterface::field_type(), get_mesh(), libMesh::MeshBase::mesh_dimension(), n_vars(), libMesh::FEInterface::n_vec_dim(), and libMesh::TYPE_VECTOR.

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

 {
   unsigned int var_num=0;
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   // 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 (; pos != end; ++pos)
       {
         // 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(pos->first);
         if (!use_current_system || pos->second->hide_output())
           continue;
 
         for (unsigned int vn=0; vn<pos->second->n_vars(); vn++)
           {
             if (FEInterface::field_type(pos->second->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 dimension. Will break for mixed dimension meshes.
     unsigned int dim = this->get_mesh().mesh_dimension();
     unsigned int nv = n_scalar_vars + dim*n_vector_vars;
 
     // We'd better not have more than dim*his->n_vars() (all vector variables)
     libmesh_assert_less_equal ( nv, dim*this->n_vars() );
 
     // Here, we're assuming the number of vector components is the same
     // as the mesh dimension. Will break for mixed dimension meshes.
 
     var_names.resize( nv );
   }
 
   // reset
   pos = _systems.begin();
 
   for (; pos != end; ++pos)
     {
       // 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(pos->first);
       if (!use_current_system || pos->second->hide_output())
         continue;
 
       for (unsigned int vn=0; vn<pos->second->n_vars(); vn++)
         {
           std::string var_name = pos->second->variable_name(vn);
           FEType fe_type = pos->second->variable_type(vn);
 
           unsigned int n_vec_dim = FEInterface::n_vec_dim( pos->second->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;
                       break;
                     case 2:
                       var_names[var_num++] = var_name+"_x";
                       var_names[var_num++] = 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";
                       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);
 }

◆ clear()

void libMesh::EquationSystems::clear ( )

virtual

Restores the data structure to a pristine state.

Definition at line 75 of file equation_systems.C.

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

Referenced by ~EquationSystems().

 {
   // Clear any additional parameters
   parameters.clear ();
 
   // clear the systems.  We must delete them
   // since we newed them!
   while (!_systems.empty())
     {
       system_iterator pos = _systems.begin();
 
       System * sys = pos->second;
       delete sys;
       sys = nullptr;
 
       _systems.erase (pos);
     }
 }

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

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

References _systems, libMesh::System::compare(), end, get_system(), n_systems(), and libMesh::out.

 {
   // 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
       const_system_iterator       pos = _systems.begin();
       const const_system_iterator end = _systems.end();
 
       for (; pos != end; ++pos)
         {
           const std::string & sys_name = pos->first;
           const System &  system        = *(pos->second);
 
           // get the other system
           const System & other_system   = other_es.get_system (sys_name);
 
           os_result.push_back (system.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;
     }
 }

◆ delete_system()

void libMesh::EquationSystems::delete_system ( const std::string & name )

Remove the system named name from the systems array.

Deprecated:: This function may not work as intended and has not been actively tested over the years. If you need the ability to delete a System from an EquationSystems object, it could probably be added.

Definition at line 441 of file equation_systems.C.

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

 {
   libmesh_deprecated();
 
   if (!_systems.count(name))
     libmesh_error_msg("ERROR: no system named " << name);
 
   delete _systems[name];
 
   _systems.erase (name);
 }

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

 {
   _enable_print_counter = false;
   return;
 }

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

References _refine_in_reinit.

519 { this->_refine_in_reinit = false; }

libMesh::EquationSystems::_refine_in_reinit

bool _refine_in_reinit

Definition: equation_systems.h:572

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

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

 {
   _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 (unsigned int i=0; i != this->n_systems(); ++i)
     {
       DofMap & dof_map = this->get_system(i).get_dof_map();
       if (enable)
         dof_map.add_default_ghosting();
       else
         dof_map.remove_default_ghosting();
     }
 }

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

 {
   _enable_print_counter = true;
   return;
 }

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

References _refine_in_reinit.

514 { this->_refine_in_reinit = true; }

libMesh::EquationSystems::_refine_in_reinit

bool _refine_in_reinit

Definition: equation_systems.h:572

◆ get_info() [1/2]

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

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

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

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

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (const auto & pr : _counts)
     {
       const std::string name(pr.first);
       const unsigned int creations    = pr.second.first;
       const unsigned int destructions = pr.second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

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

References _systems, end, and n_systems().

Referenced by print_info().

 {
   std::ostringstream oss;
 
   oss << " EquationSystems\n"
       << "  n_systems()=" << this->n_systems() << '\n';
 
   // Print the info for the individual systems
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     oss << pos->second->get_info();
 
 
   //   // Possibly print the parameters
   //   if (!this->parameters.empty())
   //     {
   //       oss << "  n_parameters()=" << this->n_parameters() << '\n';
   //       oss << "   Parameters:\n";
 
   //       for (const auto & pr : _parameters)
   //         oss << "    "
   //             << "\""
   //             << pr.first
   //             << "\""
   //             << "="
   //             << pr.second
   //             << '\n';
   //     }
 
   return oss.str();
 }

◆ get_mesh() [1/2]

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

inline

Returns: A constant reference to the mesh

Definition at line 622 of file equation_systems.h.

References _mesh.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), _read_impl(), build_variable_names(), enable_default_ghosting(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::MeshFunction::init(), reinit_solutions(), write(), libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems(), and libMesh::MeshOutput< MeshBase >::write_equation_systems().

 {
   return _mesh;
 }

◆ get_mesh() [2/2]

MeshBase & libMesh::EquationSystems::get_mesh ( )

inline

Returns: A reference to the mesh

Definition at line 630 of file equation_systems.h.

References _mesh.

 {
   return _mesh;
 }

◆ get_solution()

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

Retrieve the solution data for CONSTANT MONOMIALs. If names is populated, only the variables corresponding to those names will be retrieved. This can be used to filter which variables are retrieved.

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

Definition at line 883 of file equation_systems.C.

References build_elemental_solution_vector().

 {
   libmesh_deprecated();
   this->build_elemental_solution_vector(soln, names);
 }

◆ get_system() [1/8]

template<typename T_sys >

const T_sys & libMesh::EquationSystems::get_system ( const std::string & 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 742 of file equation_systems.h.

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

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), _read_impl(), _remove_default_ghosting(), libMesh::EnsightIO::add_scalar(), add_system(), libMesh::EnsightIO::add_vector(), adjoint_solve(), allgather(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_hessian(), libMesh::ExactSolution::attach_exact_value(), compare(), libMesh::ExactSolution::compute_error(), libMesh::GMVIO::copy_nodal_solution(), enable_default_ghosting(), libMesh::ExactSolution::error_norm(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), init(), reinit_solutions(), reinit_systems(), sensitivity_solve(), solve(), update(), libMesh::EnsightIO::write_scalar_ascii(), and libMesh::EnsightIO::write_vector_ascii().

 {
   const_system_iterator pos = _systems.find(name);
 
   // Check for errors
   if (pos == _systems.end())
     libmesh_error_msg("ERROR: no system named \"" << name << "\" found!");
 
   // Attempt dynamic cast
   return *cast_ptr<T_sys *>(pos->second);
 }

◆ get_system() [2/8]

template<typename T_sys >

T_sys & libMesh::EquationSystems::get_system ( const std::string & 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 761 of file equation_systems.h.

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

 {
   system_iterator pos = _systems.find(name);
 
   // Check for errors
   if (pos == _systems.end())
     libmesh_error_msg("ERROR: no system named " << name << " found!");
 
   // Attempt dynamic cast
   return *cast_ptr<T_sys *>(pos->second);
 }

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

References _systems, end, and n_systems().

 {
   libmesh_assert_less (num, this->n_systems());
 
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     if (pos->second->number() == num)
       break;
 
   // Check for errors
   if (pos == end)
     libmesh_error_msg("ERROR: no system number " << num << " found!");
 
   // Attempt dynamic cast
   return *cast_ptr<T_sys *>(pos->second);
 }

◆ get_system() [4/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 716 of file equation_systems.h.

References _systems, end, and n_systems().

 {
   libmesh_assert_less (num, this->n_systems());
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     if (pos->second->number() == num)
       break;
 
   // Check for errors
   if (pos == end)
     libmesh_error_msg("ERROR: no system number " << num << " found!");
 
   // Attempt dynamic cast
   return *cast_ptr<T_sys *>(pos->second);
 }

◆ get_system() [5/8]

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

inline

Returns: A constant reference to the system named name.

Definition at line 780 of file equation_systems.h.

References libMesh::Quality::name().

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

◆ get_system() [6/8]

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

inline

Returns: A writable reference to the system named name.

Definition at line 788 of file equation_systems.h.

References libMesh::Quality::name().

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

◆ get_system() [7/8]

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

inline

Returns: A constant reference to system number num.

Definition at line 796 of file equation_systems.h.

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

◆ get_system() [8/8]

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

inline

Returns: A writable reference to the system number num.

Definition at line 804 of file equation_systems.h.

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

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

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

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

 {
   unsigned int var_num=0;
 
   vars_active_subdomains.clear();
   vars_active_subdomains.resize(names.size());
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     {
       for (unsigned int vn=0; vn<pos->second->n_vars(); vn++)
         {
           std::string var_name = pos->second->variable_name(vn);
 
           auto names_it = std::find(names.begin(), names.end(), var_name);
           if(names_it != names.end())
             {
               const Variable & variable = pos->second->variable(vn);
               const std::set<subdomain_id_type> & active_subdomains = variable.active_subdomains();
               vars_active_subdomains[var_num++] = active_subdomains;
             }
         }
     }
 
   libmesh_assert_equal_to(var_num, names.size());
 }

◆ has_system()

bool libMesh::EquationSystems::has_system ( const std::string & name ) const

inline

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

Definition at line 679 of file equation_systems.h.

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

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

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

◆ increment_constructor_count()

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

inlineprotectedinherited

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

Definition at line 181 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

◆ increment_destructor_count()

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

inlineprotectedinherited

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

Definition at line 194 of file reference_counter.h.

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

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

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

◆ init()

void libMesh::EquationSystems::init ( )

virtual

Initialize all the systems

Definition at line 96 of file equation_systems.C.

References _mesh, libMesh::MeshRefinement::clean_refinement_flags(), libMesh::MeshBase::element_ptr_range(), get_system(), n_systems(), and libMesh::MeshBase::node_ptr_range().

Referenced by _read_impl(), and libMesh::ErrorVector::plot_error().

 {
   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);
 
   for (auto & elem : _mesh.element_ptr_range())
     elem->set_n_systems(n_sys);
 
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).init();
 
 #ifdef LIBMESH_ENABLE_AMR
   MeshRefinement mesh_refine(_mesh);
   mesh_refine.clean_refinement_flags();
 #endif
 }

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

References _systems, and end.

 {
   std::size_t tot=0;
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     tot += pos->second->n_active_dofs();
 
   return tot;
 }

◆ n_dofs()

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

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

Definition at line 1311 of file equation_systems.C.

References _systems, and end.

 {
   std::size_t tot=0;
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     tot += pos->second->n_dofs();
 
   return tot;
 }

◆ n_objects()

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

inlinestaticinherited

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

Definition at line 83 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

84 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:130

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

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

96 { return cast_int<processor_id_type>(_communicator.size()); }

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ n_systems()

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

inline

Returns: The number of equation systems.

Definition at line 637 of file equation_systems.h.

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(), build_discontinuous_solution_vector(), build_parallel_elemental_solution_vector(), compare(), libMesh::GMVIO::copy_nodal_solution(), enable_default_ghosting(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactSolution::ExactSolution(), get_info(), get_system(), init(), reinit_solutions(), reinit_systems(), sensitivity_solve(), solve(), and update().

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

◆ n_vars()

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

Returns: The total number of variables in all systems.

Definition at line 1296 of file equation_systems.C.

References _systems, and end.

Referenced by build_variable_names().

 {
   unsigned int tot=0;
 
   const_system_iterator       pos = _systems.begin();
   const const_system_iterator end = _systems.end();
 
   for (; pos != end; ++pos)
     tot += pos->second->n_vars();
 
   return tot;
 }

◆ print_info() [1/2]

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

staticinherited

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

Definition at line 87 of file reference_counter.C.

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

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

◆ print_info() [2/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 1279 of file equation_systems.C.

References get_info().

Referenced by libMesh::operator<<().

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

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

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

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

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ read() [1/4]

template<typename InValType >

void libMesh::EquationSystems::read	(	const std::string &	name,
		const XdrMODE	mode,
		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.

References _mesh, libMesh::MeshRefinement::clean_refinement_flags(), libMesh::Quality::name(), libMesh::out, and TRY_READ_IFEMS.

Referenced by _read_impl(), and read().

 {
   // If we have exceptions enabled we can be considerate and try
   // to read old restart files which contain infinite element
   // information but do not have the " with infinite elements"
   // string in the version information.
 
   // First try the read the user requested
   libmesh_try
     {
       this->_read_impl<InValType> (name, mode, read_flags, partition_agnostic);
     }
 
   // If that fails, try it again but explicitly request we look for infinite element info
   libmesh_catch (...)
     {
       libMesh::out << "\n*********************************************************************\n"
                    << "READING THE FILE \"" << name << "\" FAILED.\n"
                    << "It is possible this file contains infinite element information,\n"
                    << "but the version string does not contain \" with infinite elements\"\n"
                    << "Let's try this again, but looking for infinite element information...\n"
                    << "*********************************************************************\n"
                    << std::endl;
 
       libmesh_try
         {
           this->_read_impl<InValType> (name, mode, read_flags | EquationSystems::TRY_READ_IFEMS, partition_agnostic);
         }
 
       // If all that failed, we are out of ideas here...
       libmesh_catch (...)
         {
           libMesh::out << "\n*********************************************************************\n"
                        << "Well, at least we tried!\n"
                        << "Good Luck!!\n"
                        << "*********************************************************************\n"
                        << std::endl;
           LIBMESH_THROW();
         }
     }
 
 #ifdef LIBMESH_ENABLE_AMR
   MeshRefinement mesh_refine(_mesh);
   mesh_refine.clean_refinement_flags();
 #endif
 }

◆ read() [2/4]

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

inline

Definition at line 417 of file equation_systems.h.

References libMesh::Quality::name().

421 { read<Number>(name, mode, read_flags, partition_agnostic); }

libMesh::Quality::name

std::string name(const ElemQuality q)

Definition: elem_quality.C:42

◆ read() [3/4]

template<typename InValType >

void libMesh::EquationSystems::read	(	const std::string &	name,
		const unsigned int	read_flags = `(READ_HEADER \| READ_DATA)`,
		bool	partition_agnostic = `true`
	)

Definition at line 72 of file equation_systems_io.C.

References _mesh, libMesh::MeshRefinement::clean_refinement_flags(), libMesh::DECODE, libMesh::Quality::name(), libMesh::READ, and read().

 {
   XdrMODE mode = READ;
   if (name.find(".xdr") != std::string::npos)
     mode = DECODE;
   this->read(name, mode, read_flags, partition_agnostic);
 
 #ifdef LIBMESH_ENABLE_AMR
   MeshRefinement mesh_refine(_mesh);
   mesh_refine.clean_refinement_flags();
 #endif
 }

◆ read() [4/4]

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

inline

Definition at line 428 of file equation_systems.h.

References libMesh::Quality::name().

431 { read<Number>(name, read_flags, partition_agnostic); }

libMesh::Quality::name

std::string name(const ElemQuality q)

Definition: elem_quality.C:42

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

References _refine_in_reinit.

524 { return this->_refine_in_reinit; }

libMesh::EquationSystems::_refine_in_reinit

bool _refine_in_reinit

Definition: equation_systems.h:572

◆ reinit()

void libMesh::EquationSystems::reinit ( )

virtual

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

Definition at line 121 of file equation_systems.C.

References reinit_solutions(), and reinit_systems().

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), and libMesh::AdjointRefinementEstimator::estimate_error().

 {
   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();
 }

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

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

Referenced by reinit().

 {
   parallel_object_only();
 
   const unsigned int n_sys = this->n_systems();
   libmesh_assert_not_equal_to (n_sys, 0);
 
   // We may have added new systems since our last
   // EquationSystems::(re)init call
   bool _added_new_systems = false;
   for (unsigned int i=0; i != n_sys; ++i)
     if (!this->get_system(i).is_initialized())
       _added_new_systems = true;
 
   if (_added_new_systems)
     {
       // Our DofObjects will need space for the additional systems
       for (auto & node : _mesh.node_ptr_range())
         node->set_n_systems(n_sys);
 
       for (auto & elem : _mesh.element_ptr_range())
         elem->set_n_systems(n_sys);
 
       // 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(this->n_systems());
 
     // All the elements
     for (auto & elem : _mesh.element_ptr_range())
       elem->set_n_systems(this->n_systems());
   }
 
   // Localize each system's vectors
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).re_update();
 
 #ifdef LIBMESH_ENABLE_AMR
 
   bool dof_constraints_created = false;
   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 != this->n_systems(); ++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();
 
         sys.prolong_vectors();
       }
     mesh_changed = true;
     dof_constraints_created = 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 (unsigned int i=0; i != this->n_systems(); ++i)
             {
               System & sys = this->get_system(i);
               if (!dof_constraints_created)
                 {
                   sys.get_dof_map().distribute_dofs(_mesh);
                   sys.reinit_constraints();
                 }
               sys.restrict_vectors();
             }
           mesh_changed = true;
           dof_constraints_created = 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 (unsigned int i=0; i != this->n_systems(); ++i)
             {
               System & sys = this->get_system(i);
               if (!dof_constraints_created)
                 {
                   sys.get_dof_map().distribute_dofs(_mesh);
                   sys.reinit_constraints();
                 }
               sys.prolong_vectors();
             }
           mesh_changed = true;
           // dof_constraints_created = true;
         }
     }
 
   return mesh_changed;
 
 #endif // #ifdef LIBMESH_ENABLE_AMR
 
   return false;
 }

◆ reinit_systems()

void libMesh::EquationSystems::reinit_systems ( )

virtual

Reinitialize all systems on the current mesh.

Definition at line 276 of file equation_systems.C.

References get_system(), and n_systems().

Referenced by reinit().

 {
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).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 466 of file equation_systems.C.

References get_system(), and n_systems().

 {
   libmesh_assert (this->n_systems());
 
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).sensitivity_solve(parameters_in);
 }

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

References get_system(), and n_systems().

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

 {
   libmesh_assert (this->n_systems());
 
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).solve();
 }

◆ update()

void libMesh::EquationSystems::update ( )

Updates local values for all the systems

Definition at line 344 of file equation_systems.C.

References get_system(), and n_systems().

Referenced by _read_impl().

 {
   LOG_SCOPE("update()", "EquationSystems");
 
   // Localize each system's vectors
   for (unsigned int i=0; i != this->n_systems(); ++i)
     this->get_system(i).update();
 }

◆ write() [1/2]

void libMesh::EquationSystems::write	(	const std::string &	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!

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

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

Referenced by libMesh::ErrorVector::plot_error(), write(), and libMesh::NameBasedIO::write_equation_systems().

 {
   // 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())
     ;
 
   // New scope so that io will close before we try to zip the file
   {
     Xdr io((this->processor_id()==0) ? name : "", mode);
     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;
         char buf[256];
 
         // 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 & pr : _systems)
           {
             // Ignore this system if it has been marked as hidden
             if (pr.second->hide_output()) continue;
 
             // 3.)
             // Write the name of the sys_num-th system
             {
               const unsigned int sys_num = pr.second->number();
               std::string sys_name       = pr.first;
 
               comment =  "# Name, System No. ";
               std::sprintf(buf, "%u", sys_num);
               comment += buf;
 
               io.data (sys_name, comment.c_str());
             }
 
             // 4.)
             // Write the type of system handled
             {
               const unsigned int sys_num = pr.second->number();
               std::string sys_type       = pr.second->system_type();
 
               comment =  "# Type, System No. ";
               std::sprintf(buf, "%u", sys_num);
               comment += buf;
 
               io.data (sys_type, comment.c_str());
             }
 
             // 5.) - 9.)
             // Let System::write_header() do the job
             pr.second->write_header (io, version, write_additional_data);
           }
       }
 
     // Start from the first system, again,
     // to write vectors to disk, if wanted
     if (write_data)
       {
         // open a parallel buffer if warranted.
         Xdr local_io (write_parallel_files ? local_file_name(this->processor_id(),name) : "", mode);
 
         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);
           }
       }
   }
 
   // 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();
 }

◆ write() [2/2]

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

Definition at line 366 of file equation_systems_io.C.

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

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

Friends And Related Function 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 1287 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 107 of file parallel_object.h.

Referenced by build_parallel_elemental_solution_vector(), build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

◆ _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 578 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 141 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 551 of file equation_systems.h.

Referenced by _add_system_to_nodes_and_elems(), _read_impl(), allgather(), build_discontinuous_solution_vector(), build_parallel_elemental_solution_vector(), build_parallel_solution_vector(), get_mesh(), init(), read(), reinit_solutions(), and write().

◆ _mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 135 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 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), 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 572 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, System *> libMesh::EquationSystems::_systems

protected

Data structure holding the systems.

Definition at line 556 of file equation_systems.h.

Referenced by add_system(), build_discontinuous_solution_vector(), build_parallel_elemental_solution_vector(), build_parallel_solution_vector(), build_variable_names(), clear(), compare(), delete_system(), get_info(), get_system(), get_vars_active_subdomains(), has_system(), n_active_dofs(), n_dofs(), n_systems(), n_vars(), and write().

◆ parameters

Parameters libMesh::EquationSystems::parameters

Data structure holding arbitrary parameters.

Definition at line 542 of file equation_systems.h.

The documentation for this class was generated from the following files:

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

◆ const_system_iterator

◆ Counts

◆ system_iterator

Member Enumeration Documentation

◆ ReadFlags

◆ WriteFlags

Constructor & Destructor Documentation

◆ EquationSystems()

◆ ~EquationSystems()

Member Function Documentation

◆ _add_system_to_nodes_and_elems()

◆ _read_impl()

◆ _remove_default_ghosting()

◆ add_system() [1/2]

◆ add_system() [2/2]

◆ adjoint_solve()

◆ allgather()

◆ build_discontinuous_solution_vector()

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

◆ delete_system()

◆ disable_print_counter_info()

◆ disable_refine_in_reinit()

◆ enable_default_ghosting()

◆ enable_print_counter_info()

◆ enable_refine_in_reinit()

◆ get_info() [1/2]

◆ get_info() [2/2]

◆ get_mesh() [1/2]

◆ get_mesh() [2/2]

◆ get_solution()

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

◆ 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/4]

◆ read() [2/4]

◆ read() [3/4]

◆ read() [4/4]

◆ refine_in_reinit_flag()

◆ reinit()

◆ reinit_solutions()

◆ reinit_systems()