libMesh
reduced_basis_ex1.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2017 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
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 // rbOOmit: An implementation of the Certified Reduced Basis method.
19 // Copyright (C) 2009, 2010 David J. Knezevic
20 // This file is part of rbOOmit.
21
22
23
24 // <h1>Reduced Basis Example 1 - Certified Reduced Basis Method</h1>
25 // \author David Knezevic
26 // \date 2010
27 //
28 // In this example problem we use the Certified Reduced Basis method
29 // to solve a steady convection-diffusion problem on the unit square.
30 // The reduced basis method relies on an expansion of the PDE in the
31 // form \sum_q=1^Q_a theta_a^q(\mu) * a^q(u,v) = \sum_q=1^Q_f
32 // theta_f^q(\mu) f^q(v) where theta_a, theta_f are parameter
33 // dependent functions and a^q, f^q are parameter independent
34 // operators (\mu denotes a parameter).
35 //
36 // We first attach the parameter dependent functions and parameter
37 // independent operators to the RBSystem. Then in Offline mode, a
38 // reduced basis space is generated and written out to the directory
39 // "offline_data". In Online mode, the reduced basis data in
40 // "offline_data" is read in and used to solve the reduced problem for
41 // the parameters specified in reduced_basis_ex1.in.
42 //
43 // We also attach four outputs to the system which are averages over
44 // certain subregions of the domain. In Online mode, we print out the
45 // values of these outputs as well as rigorous error bounds with
46 // respect to the output associated with the "truth" finite element
47 // discretization.
48
49 // C++ include files that we need
50 #include <iostream>
51 #include <algorithm>
52 #include <cstdlib> // *must* precede <cmath> for proper std:abs() on PGI, Sun Studio CC
53 #include <cmath>
54 #include <set>
55
56 // Basic include file needed for the mesh functionality.
57 #include "libmesh/libmesh.h"
58 #include "libmesh/mesh.h"
59 #include "libmesh/mesh_generation.h"
60 #include "libmesh/exodusII_io.h"
61 #include "libmesh/equation_systems.h"
62 #include "libmesh/dof_map.h"
63 #include "libmesh/getpot.h"
64 #include "libmesh/elem.h"
65 #include "libmesh/rb_data_serialization.h"
66 #include "libmesh/rb_data_deserialization.h"
67
68 // local includes
69 #include "rb_classes.h"
70 #include "assembly.h"
71
72 // Bring in everything from the libMesh namespace
73 using namespace libMesh;
74
75 // The main program.
76 int main (int argc, char ** argv)
77 {
78  // Initialize libMesh.
79  LibMeshInit init (argc, argv);
80
81  // This example requires a linear solver package.
82  libmesh_example_requires(libMesh::default_solver_package() != INVALID_SOLVER_PACKAGE,
83  "--enable-petsc, --enable-trilinos, or --enable-eigen");
84
85 #if !defined(LIBMESH_HAVE_XDR)
86  // We need XDR support to write out reduced bases
87  libmesh_example_requires(false, "--enable-xdr");
88 #elif defined(LIBMESH_DEFAULT_SINGLE_PRECISION)
89  // XDR binary support requires double precision
90  libmesh_example_requires(false, "--disable-singleprecision");
91 #endif
92  // FIXME: This example currently segfaults with Trilinos? It works
93  // with PETSc and Eigen sparse linear solvers though.
94  libmesh_example_requires(libMesh::default_solver_package() != TRILINOS_SOLVERS, "--enable-petsc");
95
96  // Skip this 2D example if libMesh was compiled as 1D-only.
97  libmesh_example_requires(2 <= LIBMESH_DIM, "2D support");
98
99  // Parse the input file (reduced_basis_ex1.in) using GetPot
100  std::string parameters_filename = "reduced_basis_ex1.in";
101  GetPot infile(parameters_filename);
102
103  unsigned int n_elem = infile("n_elem", 1); // Determines the number of elements in the "truth" mesh
104  const unsigned int dim = 2; // The number of spatial dimensions
105
106  bool store_basis_functions = infile("store_basis_functions", true); // Do we write the RB basis functions to disk?
107
108  // Read the "online_mode" flag from the command line
109  GetPot command_line (argc, argv);
110  int online_mode = 0;
111  if (command_line.search(1, "-online_mode"))
112  online_mode = command_line.next(online_mode);
113
114  // Build a mesh on the default MPI communicator.
115  Mesh mesh (init.comm(), dim);
117  n_elem, n_elem,
118  0., 1.,
119  0., 1.,
121
122  // Create an equation systems object.
123  EquationSystems equation_systems (mesh);
124
125  // We override RBConstruction with SimpleRBConstruction in order to
126  // specialize a few functions for this particular problem.
127  SimpleRBConstruction & rb_con =
129
130  // Initialize the data structures for the equation system.
131  equation_systems.init ();
132
133  // Print out some information about the "truth" discretization
134  equation_systems.print_info();
135  mesh.print_info();
136
137  // Build a new RBEvaluation object which will be used to perform
138  // Reduced Basis calculations. This is required in both the
139  // "Offline" and "Online" stages.
140  SimpleRBEvaluation rb_eval(mesh.comm());
141
142  // We need to give the RBConstruction object a pointer to
143  // our RBEvaluation object
144  rb_con.set_rb_evaluation(rb_eval);
145
146  if (!online_mode) // Perform the Offline stage of the RB method
147  {
148  // Read in the data that defines this problem from the specified text file
149  rb_con.process_parameters_file(parameters_filename);
150
151  // Print out info that describes the current setup of rb_con
152  rb_con.print_info();
153
154  // Prepare rb_con for the Construction stage of the RB method.
155  // This sets up the necessary data structures and performs
156  // initial assembly of the "truth" affine expansion of the PDE.
158
159  // Compute the reduced basis space by computing "snapshots", i.e.
160  // "truth" solves, at well-chosen parameter values and employing
161  // these snapshots as basis functions.
162  rb_con.train_reduced_basis();
163
164  // Write out the data that will subsequently be required for the Evaluation stage
165 #if defined(LIBMESH_HAVE_CAPNPROTO)
167  rb_eval_writer.write_to_file("rb_eval.bin");
168 #else
170 #endif
171
172  // If requested, write out the RB basis functions for visualization purposes
173  if (store_basis_functions)
174  {
175  // Write out the basis functions
177  }
178
179  // Basis functions should be orthonormal, so
180  // print out the inner products to check this
182  }
183  else // Perform the Online stage of the RB method
184  {
185  // Read in the reduced basis data
186 #if defined(LIBMESH_HAVE_CAPNPROTO)
189 #else
191 #endif
192
193  // Read in online_N and initialize online parameters
194  unsigned int online_N = infile("online_N", 1);
195  Real online_x_vel = infile("online_x_vel", 0.);
196  Real online_y_vel = infile("online_y_vel", 0.);
197  RBParameters online_mu;
198  online_mu.set_value("x_vel", online_x_vel);
199  online_mu.set_value("y_vel", online_y_vel);
200  rb_eval.set_parameters(online_mu);
201  rb_eval.print_parameters();
202
203  // Now do the Online solve using the precomputed reduced basis
204  rb_eval.rb_solve(online_N);
205
206  // Print out outputs as well as the corresponding output error bounds.
207  libMesh::out << "output 1, value = " << rb_eval.RB_outputs[0]
208  << ", bound = " << rb_eval.RB_output_error_bounds[0]
209  << std::endl;
210  libMesh::out << "output 2, value = " << rb_eval.RB_outputs[1]
211  << ", bound = " << rb_eval.RB_output_error_bounds[1]
212  << std::endl;
213  libMesh::out << "output 3, value = " << rb_eval.RB_outputs[2]
214  << ", bound = " << rb_eval.RB_output_error_bounds[2]
215  << std::endl;
216  libMesh::out << "output 4, value = " << rb_eval.RB_outputs[3]
217  << ", bound = " << rb_eval.RB_output_error_bounds[3]
218  << std::endl << std::endl;
219
220  if (store_basis_functions)
221  {
222  // Read in the basis functions
224
225  // Plot the solution
227 #ifdef LIBMESH_HAVE_EXODUS_API
228  ExodusII_IO(mesh).write_equation_systems ("RB_sol.e", equation_systems);
229 #endif
230
231  // Plot the first basis function that was generated from the train_reduced_basis
232  // call in the Offline stage
234 #ifdef LIBMESH_HAVE_EXODUS_API
235  ExodusII_IO(mesh).write_equation_systems ("bf0.e", equation_systems);
236 #endif
237  }
238  }
239
240  return 0;
241 }
virtual void initialize_rb_construction(bool skip_matrix_assembly=false, bool skip_vector_assembly=false)
Allocate all the data structures necessary for the construction stage of the RB method.
This is the EquationSystems class.
virtual void write_out_basis_functions(System &sys, const std::string &directory_name="offline_data", const bool write_binary_basis_functions=true)
Write out all the basis functions to file.
virtual Real train_reduced_basis(const bool resize_rb_eval_data=true)
Train the reduced basis.
This class serializes an RBEvaluation object using the Cap&#39;n Proto library.
dof_id_type n_elem(const MeshBase::const_element_iterator &begin, const MeshBase::const_element_iterator &end)
Count up the number of elements of a specific type (as defined by an iterator range).
Definition: mesh_tools.C:656
unsigned int dim
The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs...
Definition: exodusII_io.h:52
MeshBase & mesh
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.
int main(int argc, char **argv)
The LibMeshInit class, when constructed, initializes the dependent libraries (e.g.
Definition: libmesh.h:62
The libMesh namespace provides an interface to certain functionality in the library.
SolverPackage default_solver_package()
Definition: libmesh.C:995
Load the i^th RB function into the RBConstruction solution vector.
void print_basis_function_orthogonality()
Print out a matrix that shows the orthogonality of the RB basis functions.
virtual void legacy_write_offline_data_to_files(const std::string &directory_name="offline_data", const bool write_binary_data=true)
Write out all the data to text files in order to segregate the Offline stage from the Online stage...
void print_info(std::ostream &os=libMesh::out) const
Prints information about the equation systems, by default to libMesh::out.
void init(triangulateio &t)
Initializes the fields of t to NULL/0 as necessary.
virtual void print_info()
Print out info that describes the current setup of this RBConstruction.
virtual System & add_system(const std::string &system_type, const std::string &name)
Add the system of type system_type named name to the systems array.
Write the Cap&#39;n&#39;Proto buffer to disk.
const Parallel::Communicator & comm() const
Definition: libmesh.h:81
This class is part of the rbOOmit framework.
Definition: rb_parameters.h:42
void write_to_file(const std::string &path)
Write the Cap&#39;n&#39;Proto buffer to disk.
virtual void write_equation_systems(const std::string &, const EquationSystems &, const std::set< std::string > *system_names=libmesh_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
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void set_value(const std::string &param_name, Real value)
Set the value of the specified parameter.
Definition: rb_parameters.C:57
const Parallel::Communicator & comm() const
OStreamProxy out
virtual void process_parameters_file(const std::string &parameters_filename)
Read in from the file specified by parameters_filename and set the this system&#39;s member variables acc...
This class de-serializes an RBEvaluation object using the Cap&#39;n Proto library.
RBEvaluation & get_rb_evaluation()
Get a reference to the RBEvaluation object.
virtual void init()
Initialize all the systems.