libMesh
Loading...
Searching...
No Matches
equation_systems.h
Go to the documentation of this file.
1// The libMesh Finite Element Library.
2// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3
4// This library is free software; you can redistribute it and/or
5// modify it under the terms of the GNU Lesser General Public
6// License as published by the Free Software Foundation; either
7// version 2.1 of the License, or (at your option) any later version.
8
9// This library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12// Lesser General Public License for more details.
13
14// You should have received a copy of the GNU Lesser General Public
15// License along with this library; if not, write to the Free Software
16// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
19
20#ifndef LIBMESH_EQUATION_SYSTEMS_H
21#define LIBMESH_EQUATION_SYSTEMS_H
22
23// Local Includes
24#include "libmesh/libmesh_common.h"
25#include "libmesh/parameters.h"
26#include "libmesh/system.h"
27#include "libmesh/parallel_object.h"
28
29// HP aCC needs these for some reason
30#ifdef __HP_aCC
31# include "libmesh/frequency_system.h"
32# include "libmesh/transient_system.h"
33# include "libmesh/newmark_system.h"
34# include "libmesh/steady_system.h"
35#endif
36
37// C++ includes
38#include <cstddef>
39#include <functional>
40#include <map>
41#include <set>
42#include <string>
43#include <string_view>
44#include <vector>
45#include <memory>
46
47namespace libMesh
48{
49
50// Forward Declarations
51class Elem;
52class MeshBase;
53enum XdrMODE : int;
54
69class EquationSystems : public ReferenceCountedObject<EquationSystems>,
70 public ParallelObject
71
72{
73public:
74
84
92
97
103
107 virtual void clear ();
108
112 virtual void init ();
113
118 virtual void reinit ();
119
124 virtual void reinit_mesh ();
125
138 virtual void enable_default_ghosting (bool enable);
139
143 void update ();
144
148 unsigned int n_systems() const;
149
154 bool has_system (std::string_view name) const;
155
162 template <typename T_sys>
163 const T_sys & get_system (std::string_view name) const;
164
171 template <typename T_sys>
172 T_sys & get_system (std::string_view name);
173
180 template <typename T_sys>
181 const T_sys & get_system (const unsigned int num) const;
182
189 template <typename T_sys>
190 T_sys & get_system (const unsigned int num);
191
195 const System & get_system (std::string_view name) const;
196
200 System & get_system (std::string_view name);
201
205 const System & get_system (const unsigned int num) const;
206
210 System & get_system (const unsigned int num);
211
216 virtual System & add_system (std::string_view system_type,
217 std::string_view name);
218
222 template <typename T_sys>
223 T_sys & add_system (std::string_view name);
224
229 unsigned int n_vars () const;
230
235 std::size_t n_dofs () const;
236
241 std::size_t n_active_dofs() const;
242
251 virtual void solve ();
252
261 virtual void adjoint_solve (const QoISet & qoi_indices = QoISet());
262
271 virtual void sensitivity_solve (const ParameterVector & parameters);
272
280 void build_variable_names (std::vector<std::string> & var_names,
281 const FEType * type=nullptr,
282 const std::set<std::string> * system_names=nullptr) const;
283
293 static bool is_elemental_data_fe_type (const FEType & type,
294 bool allow_high_order_discontinuous = false);
295
304 (std::vector<std::string> & var_names,
305 const std::set<std::string> * system_names=nullptr,
306 bool allow_high_order_discontinuous = false) const;
307
316 void build_solution_vector (std::vector<Number> & soln,
317 std::string_view system_name,
318 std::string_view variable_name = "all_vars") const;
319
331 void build_solution_vector (std::vector<Number> & soln,
332 const std::set<std::string> * system_names=nullptr,
333 bool add_sides=false) const;
334
343 std::unique_ptr<NumericVector<Number>>
344 build_parallel_solution_vector(const std::set<std::string> * system_names=nullptr,
345 bool add_sides=false) const;
346
351 void get_vars_active_subdomains(const std::vector<std::string> & names,
352 std::vector<std::set<subdomain_id_type>> & vars_active_subdomains) const;
353
365 void build_elemental_solution_vector (std::vector<Number> & soln,
366 std::vector<std::string> & names,
367 bool allow_high_order_discontinuous = false) const;
368
391 std::vector<std::pair<unsigned int, unsigned int>>
392 find_variable_numbers (std::vector<std::string> & names,
393 const FEType * type=nullptr,
394 const std::vector<FEType> * types=nullptr) const;
395
402 std::vector<std::pair<unsigned int, unsigned int>>
403 find_elemental_data_variable_numbers (std::vector<std::string> & names,
404 bool allow_high_order_discontinuous = false) const;
405
428 std::unique_ptr<NumericVector<Number>>
429 build_parallel_elemental_solution_vector (std::vector<std::string> & names,
430 bool allow_high_order_discontinuous = false) const;
431
449 (std::vector<Number> & soln,
450 const std::set<std::string> * system_names = nullptr,
451 const std::vector<std::string> * var_names = nullptr,
452 bool vertices_only = false,
453 bool add_sides = false) const;
454
455 /*
456 * Returns true iff the given side of the given element is *never*
457 * added to output from that element, because it is considered to be
458 * redundant with respect to the same data added from the
459 * neighboring element sharing that side. This helper function is
460 * used with the add_sides option when building solution vectors
461 * here and when outputting solution vectors in MeshOutput
462 * (currently just Exodus) I/O.
463 */
464 static bool redundant_added_side(const Elem & elem, unsigned int side);
465
466
492 template <typename InValType = Number>
493 void read (std::string_view name,
494 const XdrMODE,
495 const unsigned int read_flags=(READ_HEADER | READ_DATA),
496 bool partition_agnostic = true);
497
498 template <typename InValType = Number>
499 void read (std::string_view name,
500 const unsigned int read_flags=(READ_HEADER | READ_DATA),
501 bool partition_agnostic = true);
502
503 template <typename InValType = Number>
504 void read (Xdr & io,
505 std::function<std::unique_ptr<Xdr>()> & local_io_functor,
506 const unsigned int read_flags=(READ_HEADER | READ_DATA),
507 bool partition_agnostic = true);
508
533 void write (std::string_view name,
534 const XdrMODE,
535 const unsigned int write_flags=(WRITE_DATA),
536 bool partition_agnostic = true) const;
537
538 void write (std::string_view name,
539 const unsigned int write_flags=(WRITE_DATA),
540 bool partition_agnostic = true) const;
541
542 void write (std::ostream name,
543 const unsigned int write_flags=(WRITE_DATA),
544 bool partition_agnostic = true) const;
545
546 void write (Xdr & io,
547 const unsigned int write_flags=(WRITE_DATA),
548 bool partition_agnostic = true,
549 Xdr * const local_io = nullptr) const;
550
557 virtual bool compare (const EquationSystems & other_es,
558 const Real threshold,
559 const bool verbose) const;
560
565 virtual std::string get_info() const;
566
571 void print_info (std::ostream & os=libMesh::out) const;
572
576 friend std::ostream & operator << (std::ostream & os,
577 const EquationSystems & es);
578
582 const MeshBase & get_mesh() const;
583
587 MeshBase & get_mesh();
588
593 void allgather ();
594
599
604
609
616 bool reinit_solutions ();
617
621 virtual void reinit_systems ();
622
627
628
629protected:
630
631
636
640 std::map<std::string, std::unique_ptr<System>, std::less<>> _systems;
641
647
653
654private:
658 std::vector<std::pair<unsigned int, unsigned int>>
660 (std::vector<std::string> & names,
661 const std::function<bool(const FEType &)> & type_filter) const;
662
670
675 void _remove_default_ghosting(unsigned int sys_num);
676};
677
678
679
680// ------------------------------------------------------------
681// EquationSystems inline methods
682inline
684{
685 return _mesh;
686}
687
688
689
690inline
692{
693 return _mesh;
694}
695
696
697inline
698unsigned int EquationSystems::n_systems () const
699{
700 return cast_int<unsigned int>(_systems.size());
701}
702
703
704
705
706template <typename T_sys>
707inline
708T_sys & EquationSystems::add_system (std::string_view name)
709{
710 if (!_systems.count(name))
711 {
712 const unsigned int sys_num = this->n_systems();
713
714 auto result = _systems.emplace
715 (name, std::make_unique<T_sys>(*this, std::string(name),
716 sys_num));
717
719 this->_remove_default_ghosting(sys_num);
720
721 // Tell all the \p DofObject entities to add a system.
723
724 // Return reference to newly added item
725 auto it = result.first;
726 auto & sys_ptr = it->second;
727 return cast_ref<T_sys &>(*sys_ptr);
728 }
729 else
730 {
731 // We now allow redundant add_system calls, to make it
732 // easier to load data from files for user-derived system
733 // subclasses
734 return this->get_system<T_sys>(name);
735 }
736}
737
738
739
740inline
741bool EquationSystems::has_system (std::string_view name) const
742{
743 if (_systems.find(name) == _systems.end())
744 return false;
745 return true;
746}
747
748
749
750
751template <typename T_sys>
752inline
753const T_sys & EquationSystems::get_system (const unsigned int num) const
754{
755 libmesh_assert_less (num, this->n_systems());
756
757 for (auto & pr : _systems)
758 {
759 const auto & sys_ptr = pr.second;
760 if (sys_ptr->number() == num)
761 return cast_ref<const T_sys &>(*sys_ptr);
762 }
763 // Error if we made it here
764 libmesh_error_msg("ERROR: no system number " << num << " found!");
765}
766
767
768
769
770template <typename T_sys>
771inline
772T_sys & EquationSystems::get_system (const unsigned int num)
773{
774 libmesh_assert_less (num, this->n_systems());
775
776 for (auto & pr : _systems)
777 {
778 auto & sys_ptr = pr.second;
779 if (sys_ptr->number() == num)
780 return cast_ref<T_sys &>(*sys_ptr);
781 }
782
783 // Error if we made it here
784 libmesh_error_msg("ERROR: no system number " << num << " found!");
785}
786
787
788
789
790
791
792template <typename T_sys>
793inline
794const T_sys & EquationSystems::get_system (std::string_view name) const
795{
796 auto pos = _systems.find(name);
797
798 // Check for errors
799 libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named \"" << name << "\" found!");
800
801 // Attempt dynamic cast
802 const auto & sys_ptr = pos->second;
803 return cast_ref<const T_sys &>(*sys_ptr);
804}
805
806
807
808
809
810
811template <typename T_sys>
812inline
813T_sys & EquationSystems::get_system (std::string_view name)
814{
815 auto pos = _systems.find(name);
816
817 // Check for errors
818 libmesh_error_msg_if(pos == _systems.end(), "ERROR: no system named " << name << " found!");
819
820 // Attempt dynamic cast
821 auto & sys_ptr = pos->second;
822 return cast_ref<T_sys &>(*sys_ptr);
823}
824
825
826
827
828
829
830
831inline
832const System & EquationSystems::get_system (std::string_view name) const
833{
834 return this->get_system<System>(name);
835}
836
837
838
839inline
840System & EquationSystems::get_system (std::string_view name)
841{
842 return this->get_system<System>(name);
843}
844
845
846
847inline
848const System & EquationSystems::get_system (const unsigned int num) const
849{
850 return this->get_system<System>(num);
851}
852
853
854
855inline
856System & EquationSystems::get_system (const unsigned int num)
857{
858 return this->get_system<System>(num);
859}
860
861
862} // namespace libMesh
863
864
865#endif // LIBMESH_EQUATION_SYSTEMS_H
void ErrorVector unsigned int
This is the base class from which all geometric element types are derived.
Definition elem.h:96
This is the EquationSystems class.
virtual bool compare(const EquationSystems &other_es, const Real threshold, const bool verbose) const
virtual void reinit()
Handle any mesh changes and reinitialize all the systems on the updated mesh.
std::vector< std::pair< unsigned int, unsigned int > > find_variable_numbers_by_predicate(std::vector< std::string > &names, const std::function< bool(const FEType &)> &type_filter) const
Implementation detail for find_variable_numbers() variants.
virtual std::string get_info() const
void enable_refine_in_reinit()
Calls to reinit() will also do two-step coarsen-then-refine.
void build_elemental_data_variable_names(std::vector< std::string > &var_names, const std::set< std::string > *system_names=nullptr, bool allow_high_order_discontinuous=false) const
Filter var_names to names of variables that can be represented as elemental data.
void print_info(std::ostream &os=libMesh::out) const
Prints information about the equation systems, by default to libMesh::out.
std::unique_ptr< NumericVector< Number > > build_parallel_solution_vector(const std::set< std::string > *system_names=nullptr, bool add_sides=false) const
A version of build_solution_vector which is appropriate for "parallel" output formats like Nemesis.
friend std::ostream & operator<<(std::ostream &os, const EquationSystems &es)
Same as above, but allows you to also use stream syntax.
virtual ~EquationSystems()
Destructor.
virtual void sensitivity_solve(const ParameterVector &parameters)
Call sensitivity_solve on all the individual equation systems.
void _remove_default_ghosting(unsigned int sys_num)
This just calls DofMap::remove_default_ghosting() but using a shim lets us forward-declare DofMap.
std::size_t n_active_dofs() const
void update()
Updates local values for all the systems.
std::vector< std::pair< unsigned int, unsigned int > > find_variable_numbers(std::vector< std::string > &names, const FEType *type=nullptr, const std::vector< FEType > *types=nullptr) const
Finds system and variable numbers for any variables of 'type' or of 'types' corresponding to the entr...
void write(std::string_view name, const XdrMODE, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
Write the systems to disk using the XDR data format.
void 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.
unsigned int n_systems() const
static bool redundant_added_side(const Elem &elem, unsigned int side)
unsigned int n_vars() const
WriteFlags
Define enumeration to set properties in EquationSystems::write()
void get_vars_active_subdomains(const std::vector< std::string > &names, std::vector< std::set< subdomain_id_type > > &vars_active_subdomains) const
Retrieve vars_active_subdomains, which indicates the active subdomains for each variable in names.
void read(std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
Read & initialize the systems from disk using the XDR data format.
const MeshBase & get_mesh() const
Parameters parameters
Data structure holding arbitrary parameters.
std::vector< std::pair< unsigned int, unsigned int > > find_elemental_data_variable_numbers(std::vector< std::string > &names, bool allow_high_order_discontinuous=false) const
Finds system and variable numbers for variables that can be represented as elemental data.
void build_solution_vector(std::vector< Number > &soln, std::string_view system_name, std::string_view variable_name="all_vars") const
Fill the input vector soln with the solution values for the system named name.
bool has_system(std::string_view name) const
bool _refine_in_reinit
Flag for whether to call coarsen/refine in reinit().
void write(std::ostream name, const unsigned int write_flags=(WRITE_DATA), bool partition_agnostic=true) const
ReadFlags
Define enumeration to set properties in EquationSystems::read()
std::unique_ptr< NumericVector< Number > > build_parallel_elemental_solution_vector(std::vector< std::string > &names, bool allow_high_order_discontinuous=false) const
Builds a parallel vector of elemental data solution values corresponding to the entries in the input ...
MeshBase & _mesh
The mesh data structure.
bool reinit_solutions()
Handle any mesh changes and project any solutions onto the updated mesh.
virtual void init()
Initialize all the systems.
void build_elemental_solution_vector(std::vector< Number > &soln, std::vector< std::string > &names, bool allow_high_order_discontinuous=false) const
Retrieve the solution data for elemental data variables.
virtual System & add_system(std::string_view system_type, std::string_view name)
Add the system of type system_type named name to the systems array.
virtual void reinit_mesh()
Handle the association of a completely new mesh with the EquationSystem and all the Systems assigned ...
virtual void adjoint_solve(const QoISet &qoi_indices=QoISet())
Call adjoint_solve on all the individual equation systems.
virtual void reinit_systems()
Reinitialize all systems on the current mesh.
virtual void clear()
Restores the data structure to a pristine state.
void _add_system_to_nodes_and_elems()
This function is used in the implementation of add_system, it loops over the nodes and elements of th...
const T_sys & get_system(std::string_view name) const
virtual void enable_default_ghosting(bool enable)
Enable or disable default ghosting functors on the Mesh and on all Systems.
static bool is_elemental_data_fe_type(const FEType &type, bool allow_high_order_discontinuous=false)
void build_discontinuous_solution_vector(std::vector< Number > &soln, const std::set< std::string > *system_names=nullptr, const std::vector< std::string > *var_names=nullptr, bool vertices_only=false, bool add_sides=false) const
Fill the input vector soln with solution values.
void disable_refine_in_reinit()
Calls to reinit() will not try to coarsen or refine the mesh.
std::size_t n_dofs() const
virtual void solve()
Call solve on all the individual equation systems.
bool _enable_default_ghosting
Flag for whether to enable default ghosting on newly added Systems.
std::map< std::string, std::unique_ptr< System >, std::less<> > _systems
Data structure holding the systems.
void allgather()
Serializes a distributed mesh and its associated degree of freedom numbering for all systems.
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition fe_type.h:197
This is the MeshBase class.
Definition mesh_base.h:81
An object whose state is distributed along a set of processors.
Data structure for specifying which Parameters should be independent variables in a parameter sensiti...
This class provides the ability to map between arbitrary, user-defined strings and several data types...
Definition parameters.h:75
Data structure for specifying which Quantities of Interest should be calculated in an adjoint or a pa...
Definition qoi_set.h:46
This class implements reference counting.
Manages consistently variables, degrees of freedom, and coefficient vectors.
Definition system.h:100
This class implements a C++ interface to the XDR (eXternal Data Representation) format.
Definition xdr_cxx.h:68
MeshBase & mesh
The libMesh namespace provides an interface to certain functionality in the library.
OStreamProxy out
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
XdrMODE
Defines an enum for read/write mode in Xdr format.