libMesh
Loading...
Searching...
No Matches
Public Member Functions | List of all members
WriteVecAndScalar Class Reference
Inheritance diagram for WriteVecAndScalar:
[legend]

Public Member Functions

 LIBMESH_CPPUNIT_TEST_SUITE (WriteVecAndScalar)
 This test ensures you can write both vector and scalar variables.
 
 CPPUNIT_TEST (testWriteExodusDistributed)
 
 CPPUNIT_TEST (testWriteExodusReplicated)
 
 CPPUNIT_TEST (testWriteNemesisDistributed)
 
 CPPUNIT_TEST (testWriteNemesisReplicated)
 
 CPPUNIT_TEST_SUITE_END ()
 
void setupTests (UnstructuredMesh &mesh, EquationSystems &equation_systems)
 
void testSolution (const MeshBase &read_mesh, const System &sys2)
 
template<typename MeshType >
void testWriteExodus (const std::string &filename)
 
void testWriteExodusReplicated ()
 
void testWriteExodusDistributed ()
 
template<typename MeshType >
void testWriteNemesis (const std::string &filename)
 
void testWriteNemesisReplicated ()
 
void testWriteNemesisDistributed ()
 

Detailed Description

Definition at line 20 of file write_vec_and_scalar.C.

Member Function Documentation

◆ CPPUNIT_TEST() [1/4]

WriteVecAndScalar::CPPUNIT_TEST ( testWriteExodusDistributed  )

◆ CPPUNIT_TEST() [2/4]

WriteVecAndScalar::CPPUNIT_TEST ( testWriteExodusReplicated  )

◆ CPPUNIT_TEST() [3/4]

WriteVecAndScalar::CPPUNIT_TEST ( testWriteNemesisDistributed  )

◆ CPPUNIT_TEST() [4/4]

WriteVecAndScalar::CPPUNIT_TEST ( testWriteNemesisReplicated  )

◆ CPPUNIT_TEST_SUITE_END()

WriteVecAndScalar::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE()

WriteVecAndScalar::LIBMESH_CPPUNIT_TEST_SUITE ( WriteVecAndScalar  )

This test ensures you can write both vector and scalar variables.

◆ setupTests()

void WriteVecAndScalar::setupTests ( UnstructuredMesh &  mesh,
EquationSystems &  equation_systems 
)
inline

Definition at line 39 of file write_vec_and_scalar.C.

40 {
41 // We set our initial conditions based on build_square node ids
42 mesh.allow_renumbering(false);
43
44 MeshTools::Generation::build_square(mesh,
45 1, 1,
46 -1., 1.,
47 -1., 1.,
48 Utility::string_to_enum<ElemType>("TRI6"));
49
50 ExplicitSystem & system = equation_systems.add_system<ExplicitSystem>("Tester");
51 system.add_variable("u", FIRST, NEDELEC_ONE);
52 system.add_variable("v", FIRST, LAGRANGE);
53
54 // Initialize the system
55 equation_systems.init();
56
57 // Mimic the initial conditions of u(i)=2*i in the serial case,
58 // but indexed by node id rather than dof id.
59 std::vector<Real> initial_vector({10, 0, 12, 8, 4, 2, 16, 6, 14});
60
61 NumericVector<Number> & sys_solution = *(system.solution);
62 for (const auto & node : mesh.node_ptr_range())
63 {
64 dof_id_type dof_id;
65 if (node->n_comp(0,0))
66 {
67 dof_id = node->dof_number(0,0,0);
68 }
69 else
70 {
71 CPPUNIT_ASSERT(node->n_comp(0,1));
72 dof_id = node->dof_number(0,1,0);
73 }
74 if (dof_id >= sys_solution.first_local_index() &&
75 dof_id < sys_solution.last_local_index())
76 sys_solution.set(dof_id, initial_vector[node->id()]);
77 if (mesh.n_processors() == 1)
78 CPPUNIT_ASSERT_EQUAL(initial_vector[node->id()], dof_id*Real(2));
79 }
80 sys_solution.close();
81 }
libMesh::EquationSystems::init
virtual void init()
Initialize all the systems.
Definition equation_systems.C:80
libMesh::EquationSystems::add_system
virtual System & add_system(std::string_view system_type, std::string_view name)
Add the system of type system_type named name to the systems array.
Definition equation_systems.C:353
libMesh::ExplicitSystem
Manages consistently variables, degrees of freedom, and coefficient vectors for explicit systems.
Definition explicit_system.h:49
libMesh::MeshBase::allow_renumbering
void allow_renumbering(bool allow)
If false is passed in then this mesh will no longer be renumbered when being prepared for use.
Definition mesh_base.h:1355
libMesh::NumericVector
Provides a uniform interface to vector storage schemes for different linear algebra libraries.
Definition numeric_vector.h:70
libMesh::ParallelObject::n_processors
processor_id_type n_processors() const
Definition parallel_object.h:103
libMesh::System::add_variable
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition system.C:1344
libMesh::System::solution
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition system.h:1655
mesh
MeshBase & mesh
Definition mesh_communication.C:1460
libMesh::MeshTools::Generation::build_square
void build_square(UnstructuredMesh &mesh, const unsigned int nx, const unsigned int ny, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
A specialized build_cube() for 2D meshes.
Definition mesh_generation.C:1981
libMesh::dof_id_type
uint8_t dof_id_type
Definition id_types.h:67
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::ParallelObject::n_processors(), libMesh::NEDELEC_ONE, libMesh::Real, and libMesh::System::solution.

Referenced by testWriteExodus(), and testWriteNemesis().

◆ testSolution()

void WriteVecAndScalar::testSolution ( const MeshBase &  read_mesh,
const System &  sys2 
)
inline

Definition at line 84 of file write_vec_and_scalar.C.

85 {
86 // VariableGroup optimization means that DoFs iterate over each of
87 // the 3 variables on each node before proceeding to the next
88 // node.
89 // u_x, u_y, v
90 const std::vector<Real> gold_vector = {-1, 3, 10,
91 0, 1, 12,
92 2, 0, 14,
93 0, 1.5, 11,
94 0.5, 1, 13,
95 0.5, 1.5, 12,
96 3, 4, 16,
97 3, 1.5, 15,
98 0.5, 4, 13};
99
100 // Translation from node id to dof indexing order as gets done in
101 // serial
102 const std::vector<dof_id_type>
103 node_reordering({0, 3, 1, 8, 5, 4, 6, 7, 2});
104
105 Real tol = 1e-12;
106 NumericVector<Number> & sys2_soln(*sys2.solution);
107 for (const auto & node : read_mesh.node_ptr_range())
108 {
109 if (node->processor_id() != read_mesh.processor_id())
110 continue;
111
112 // We write out real, imaginary, and magnitude for complex
113 // numbers
114#ifdef LIBMESH_USE_COMPLEX_NUMBERS
115 const unsigned int v2 = 3;
116#else
117 const unsigned int v2 = 1;
118#endif
119 CPPUNIT_ASSERT_EQUAL(node->n_vars(0), 3*v2);
120
121 CPPUNIT_ASSERT_LESS(node_reordering.size(), std::size_t(node->id()));
122 const dof_id_type gold_i_ux = node_reordering[node->id()] * 3;
123 const dof_id_type gold_i_uy = gold_i_ux + 1;
124 const dof_id_type gold_i_v = gold_i_uy + 1;
125 CPPUNIT_ASSERT_LESS(gold_vector.size(), std::size_t(gold_i_v));
126
127 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,0,0)),
128 gold_vector[gold_i_ux], tol);
129 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,v2,0)),
130 gold_vector[gold_i_uy], tol);
131 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,2*v2,0)),
132 gold_vector[gold_i_v], tol);
133
134 // Let's check imaginary parts and magnitude for good measure
135#ifdef LIBMESH_USE_COMPLEX_NUMBERS
136 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,1,0)),
137 0.0, tol);
138 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,2,0)),
139 std::abs(gold_vector[gold_i_ux]), tol);
140 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,4,0)),
141 0.0, tol);
142 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,5,0)),
143 std::abs(gold_vector[gold_i_uy]), tol);
144 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,7,0)),
145 0.0, tol);
146 LIBMESH_ASSERT_NUMBERS_EQUAL(sys2_soln(node->dof_number(0,8,0)),
147 std::abs(gold_vector[gold_i_v]), tol);
148#endif
149 }
150 }
libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition parallel_object.h:114

References libMesh::ParallelObject::processor_id(), libMesh::Real, and libMesh::System::solution.

Referenced by testWriteExodus().

◆ testWriteExodus()

template<typename MeshType >
void WriteVecAndScalar::testWriteExodus ( const std::string &  filename)
inline

Definition at line 155 of file write_vec_and_scalar.C.

156 {
157 MeshType mesh(*TestCommWorld);
158 EquationSystems equation_systems(mesh);
159
160 setupTests(mesh, equation_systems);
161
162 // Make sure any previous reads are done before the writing starts
163 TestCommWorld->barrier();
164
165 // We write the file in the ExodusII format.
166 ExodusII_IO(mesh).write_equation_systems(filename, equation_systems);
167
168 // Make sure that the writing is done before the reading starts.
169 TestCommWorld->barrier();
170
171 // Now read it back in
172 MeshType read_mesh(*TestCommWorld);
173 read_mesh.allow_renumbering(false);
174 ExodusII_IO exio(read_mesh);
175 exio.read(filename);
176
177 read_mesh.prepare_for_use();
178 EquationSystems es2(read_mesh);
179 ExplicitSystem & sys2 = es2.add_system<ExplicitSystem>("Test");
180
181 const std::vector<std::string> & nodal_vars(exio.get_nodal_var_names());
182
183 for (const auto & var_name : nodal_vars)
184 sys2.add_variable(var_name, SECOND, LAGRANGE);
185
186 es2.init();
187
188 for (const auto & var_name : nodal_vars)
189 exio.copy_nodal_solution(sys2, var_name, var_name, 1);
190
191 testSolution(read_mesh, sys2);
192 }
WriteVecAndScalar::testSolution
void testSolution(const MeshBase &read_mesh, const System &sys2)
Definition write_vec_and_scalar.C:84
WriteVecAndScalar::setupTests
void setupTests(UnstructuredMesh &mesh, EquationSystems &equation_systems)
Definition write_vec_and_scalar.C:39
libMesh::EquationSystems
This is the EquationSystems class.
Definition equation_systems.h:72
libMesh::ExodusII_IO
The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs...
Definition exodusII_io.h:53
libMesh::ExodusII_IO::write_equation_systems
virtual void write_equation_systems(const std::string &fname, const EquationSystems &es, const std::set< std::string > *system_names=nullptr) override
Writes out the solution for no specific time or timestep.
Definition exodusII_io.C:2130
libMesh::System::init
void init()
Initializes degrees of freedom on the current mesh.
Definition system.C:196
TestCommWorld
Communicator * TestCommWorld

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::get_nodal_var_names(), libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::ExodusII_IO::read(), libMesh::SECOND, setupTests(), TestCommWorld, testSolution(), and libMesh::ExodusII_IO::write_equation_systems().

◆ testWriteExodusDistributed()

void WriteVecAndScalar::testWriteExodusDistributed ( )
inline

Definition at line 195 of file write_vec_and_scalar.C.

195{ LOG_UNIT_TEST; testWriteExodus<DistributedMesh>("dist.e"); }

◆ testWriteExodusReplicated()

void WriteVecAndScalar::testWriteExodusReplicated ( )
inline

Definition at line 194 of file write_vec_and_scalar.C.

194{ LOG_UNIT_TEST; testWriteExodus<ReplicatedMesh>("rep.e"); }

◆ testWriteNemesis()

template<typename MeshType >
void WriteVecAndScalar::testWriteNemesis ( const std::string &  filename)
inline

Definition at line 201 of file write_vec_and_scalar.C.

202 {
203 MeshType mesh(*TestCommWorld);
204 EquationSystems equation_systems(mesh);
205
206 setupTests(mesh, equation_systems);
207
208 // Make sure any previous reads are done before the writing starts
209 TestCommWorld->barrier();
210
211 // We write the file in the Nemesis format.
212 Nemesis_IO(mesh).write_equation_systems(filename, equation_systems);
213
214 // Make sure that the writing is done before the reading starts.
215 TestCommWorld->barrier();
216
217 // Now read it back in
218 MeshType read_mesh(*TestCommWorld);
219 read_mesh.allow_renumbering(false);
220 Nemesis_IO nemio(read_mesh);
221 nemio.read(filename);
222
223 read_mesh.prepare_for_use();
224 EquationSystems es2(read_mesh);
225 ExplicitSystem & sys2 = es2.add_system<ExplicitSystem>("Test");
226
227 const std::vector<std::string> & nodal_vars(nemio.get_nodal_var_names());
228
229 for (const auto & var_name : nodal_vars)
230 sys2.add_variable(var_name, SECOND, LAGRANGE);
231
232 es2.init();
233
234 for (const auto & var_name : nodal_vars)
235 nemio.copy_nodal_solution(sys2, var_name, var_name, 1);
236
237 // FIXME - Nemesis still needs work for vector-valued variables
238 // testSolution(read_mesh, sys2);
239 }
libMesh::MeshOutput::write_equation_systems
virtual void write_equation_systems(const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
This method implements writing a mesh with data to a specified file where the data is taken from the ...
Definition mesh_output.C:31
libMesh::Nemesis_IO
The Nemesis_IO class implements reading parallel meshes in the Nemesis file format from Sandia Nation...
Definition nemesis_io.h:54

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::Nemesis_IO::copy_nodal_solution(), libMesh::Nemesis_IO::get_nodal_var_names(), libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::Nemesis_IO::read(), libMesh::SECOND, setupTests(), TestCommWorld, and libMesh::MeshOutput< MT >::write_equation_systems().

◆ testWriteNemesisDistributed()

void WriteVecAndScalar::testWriteNemesisDistributed ( )
inline

Definition at line 242 of file write_vec_and_scalar.C.

242{ LOG_UNIT_TEST; testWriteNemesis<DistributedMesh>("dist.nem"); }

◆ testWriteNemesisReplicated()

void WriteVecAndScalar::testWriteNemesisReplicated ( )
inline

Definition at line 241 of file write_vec_and_scalar.C.

241{ LOG_UNIT_TEST; testWriteNemesis<ReplicatedMesh>("rep.nem"); }
The documentation for this class was generated from the following file:
Generated on Fri Aug 21 2026 13:32:37 for libMesh by doxygen 1.9.8