GRINS-0.8.0
Functions
generic_amr_testing_app.C File Reference
#include "grins_config.h"
#include "grins/grins_enums.h"
#include "grins/mesh_builder.h"
#include "grins/simulation.h"
#include "grins/simulation_builder.h"
#include "grins/multiphysics_sys.h"
#include "libmesh/exact_solution.h"
#include "libmesh/parsed_function.h"
#include "libmesh/composite_function.h"
Include dependency graph for generic_amr_testing_app.C:

Go to the source code of this file.

Functions

int test_error_norm (libMesh::ExactSolution &exact_sol, const std::string &system_name, const std::string &var, const std::string &norm, const libMesh::Real exact_error, const double tol)
 
int main (int argc, char *argv[])
 

Function Documentation

int main ( int  argc,
char *  argv[] 
)

Definition at line 46 of file generic_amr_testing_app.C.

References test_error_norm().

47 {
48  GetPot command_line(argc,argv);
49 
50  if( !command_line.have_variable("input") )
51  {
52  std::cerr << "ERROR: Must specify input file on command line with input=<file>."
53  << std::endl;
54  exit(1);
55  }
56 
57  if( !command_line.have_variable("test_data_prefix") )
58  {
59  std::cerr << "ERROR: Must specify solution test data filename prefix on command line with test_data_prefix=<string>."
60  << std::endl;
61  exit(1);
62  }
63 
64  if( !command_line.have_variable("mesh_data_prefix") )
65  {
66  std::cerr << "ERROR: Must specify solution mesh data filename prefix on command line with test_data_prefix=<string>."
67  << std::endl;
68  exit(1);
69  }
70 
71  if( !command_line.have_variable("gold_data_prefix") )
72  {
73  std::cerr << "ERROR: Must specify solution gold data filename prefix on command line with gold_data_prefix=<string>."
74  << std::endl;
75  exit(1);
76  }
77 
78  if( !command_line.have_variable("gold_mesh_prefix") )
79  {
80  std::cerr << "ERROR: Must specify gold mesh data filename prefix on command line with gold_mesh_prefix=<string>."
81  << std::endl;
82  exit(1);
83  }
84 
85  if( !command_line.have_variable("vars") )
86  {
87  std::cerr << "ERROR: Must specify variables on command line with vars='var1 var2'"
88  << std::endl;
89  exit(1);
90  }
91 
92  if( !command_line.have_variable("norms") )
93  {
94  std::cerr << "ERROR: Must specify error norms on command line with norms='L2 H1'"
95  << std::endl;
96  exit(1);
97  }
98 
99  if( !command_line.have_variable("tol") )
100  {
101  std::cerr << "ERROR: Must specify test tolerance on command line with tol=<double>"
102  << std::endl;
103  exit(1);
104  }
105 
106  if( !command_line.have_variable("n_steps") )
107  {
108  std::cerr << "ERROR: Must specify n_steps on command line with n_steps=<int>"
109  << std::endl;
110  exit(1);
111  }
112 
113 
114 
115  // Grab the variables for which we want to compare the errors
116  unsigned int n_vars = command_line.vector_variable_size("vars");
117  std::vector<std::string> vars(n_vars);
118  for( unsigned int v = 0; v < n_vars; v++ )
119  {
120  vars[v] = command_line("vars", "DIE!", v);
121  }
122 
123  // Now grab the norms to compute for each variable error
124  unsigned int n_norms = command_line.vector_variable_size("norms");
125  std::vector<std::string> norms(n_norms);
126  for( unsigned int n = 0; n < n_norms; n++ )
127  {
128  norms[n] = command_line("norms", "DIE!", n);
129  if( norms[n] != std::string("L2") )
130  {
131  std::cerr << "ERROR: Invalid norm input " << norms[n] << std::endl
132  << " Valid values are: L2" << std::endl;
133  }
134  }
135 
136  // Grab the input filename
137  std::string input_filename = command_line("input", "DIE!");
138 
139  // Check that the input file is actually there
140  {
141  std::ifstream i(input_filename.c_str());
142  if (!i)
143  {
144  std::cerr << "Error: Could not read from input file "
145  << input_filename << std::endl;
146  exit(1);
147  }
148  }
149 
150  // Create our GetPot object.
151  GetPot input( input_filename );
152 
153  // Initialize libMesh library
154  libMesh::LibMeshInit libmesh_init(argc, argv);
155 
156  std::string test_data_prefix = command_line("test_data_prefix", "DIE!" );
157  std::string mesh_data_prefix = command_line("mesh_data_prefix", "DIE!" );
158 
159  std::string gold_data_prefix = command_line("gold_data_prefix", "DIE!" );
160  std::string gold_mesh_prefix = command_line("gold_mesh_prefix", "DIE!" );
161 
162  unsigned int n_steps = command_line("n_steps", 0);
163 
164  int return_flag = 0;
165 
166  std::string system_name = "GRINS-TEST";
167 
168  for( unsigned int s = 0; s < n_steps; s++ )
169  {
170  std::stringstream step_string;
171  step_string << s;
172 
173  //FIXME: Need to support different input formats for meshes
174  std::string mesh_filename = mesh_data_prefix+"."+step_string.str()+"_mesh.xda";
175  {
176  std::ifstream i( mesh_filename.c_str());
177  if (!i)
178  {
179  std::cerr << "Error: Could not read from mesh_data file "
180  << mesh_filename << std::endl;
181  exit(1);
182  }
183  }
184 
185  libMesh::Mesh mesh(libmesh_init.comm());
186  mesh.read(mesh_filename);
187 
188  // This needs to match the read counter-part in GRINS::Simulation
189  //FIXME: Need to support different input formats for restarts
190  std::string test_data = test_data_prefix+"."+step_string.str()+".xdr";
191 
192  {
193  std::ifstream i(test_data.c_str());
194  if (!i)
195  {
196  std::cerr << "Error: Could not read from test_data file "
197  << test_data << std::endl;
198  exit(1);
199  }
200  }
201 
202  libMesh::EquationSystems es(mesh);
203  es.read(test_data,
204  GRINSEnums::DECODE,
205  libMesh::EquationSystems::READ_HEADER |
206  libMesh::EquationSystems::READ_DATA |
207  libMesh::EquationSystems::READ_ADDITIONAL_DATA);
208 
209  // Now grab the "gold" mesh and data
210  //FIXME: Need to support different input formats for meshes
211  std::string gold_mesh_filename = gold_mesh_prefix+"_mesh."+step_string.str()+".exo";
212  {
213  std::ifstream i( gold_mesh_filename.c_str());
214  if (!i)
215  {
216  std::cerr << "Error: Could not read from gold_mesh file "
217  << gold_mesh_filename << std::endl;
218  exit(1);
219  }
220  }
221 
222  libMesh::Mesh gold_mesh(libmesh_init.comm());
223  gold_mesh.read(gold_mesh_filename);
224 
225  // This needs to match the read counter-part in GRINS::Simulation
226  //FIXME: Need to support different input formats for restarts
227  std::string gold_data = gold_data_prefix+"."+step_string.str()+".xdr";
228 
229  {
230  std::ifstream i(gold_data.c_str());
231  if (!i)
232  {
233  std::cerr << "Error: Could not read from test_data file "
234  << gold_data << std::endl;
235  exit(1);
236  }
237  }
238 
239  libMesh::EquationSystems es_gold(gold_mesh);
240  es_gold.read(gold_data,
241  GRINSEnums::DECODE,
242  libMesh::EquationSystems::READ_HEADER |
243  libMesh::EquationSystems::READ_DATA |
244  libMesh::EquationSystems::READ_ADDITIONAL_DATA);
245 
246  // Create Exact solution object and attach "gold" EquationSystems
247  libMesh::ExactSolution exact_sol(es);
248 
249  exact_sol.attach_reference_solution( &es_gold );
250 
251  // Now compute error for each variable
252  for( unsigned int v = 0; v < n_vars; v++ )
253  {
254  exact_sol.compute_error(system_name, vars[v]);
255  }
256 
257  double tol = command_line("tol", 1.0e-10);
258 
259  return_flag = 0;
260  int test_flag = 0;
261 
262  // We're just diffing against gold data, so error should be 0
263  double exact_error = 0.0;
264 
265  // Now test error for each variable, for each norm
266  for( unsigned int v = 0; v < n_vars; v++ )
267  {
268  for( unsigned int n = 0; n < n_norms; n++ )
269  {
270  test_flag = test_error_norm( exact_sol, system_name, vars[v], norms[n], exact_error, tol );
271 
272  if( test_flag == 1 )
273  return_flag = 1;
274  }
275  }
276 
277  // Break out if one of the tests failed
278  if( return_flag == 1 )
279  break;
280  }
281 
282  return return_flag;
283 }
int test_error_norm(libMesh::ExactSolution &exact_sol, const std::string &system_name, const std::string &var, const std::string &norm, const libMesh::Real exact_error, const double tol)
int test_error_norm ( libMesh::ExactSolution &  exact_sol,
const std::string &  system_name,
const std::string &  var,
const std::string &  norm,
const libMesh::Real  exact_error,
const double  tol 
)

Definition at line 285 of file generic_amr_testing_app.C.

Referenced by main().

291 {
292  int return_flag = 0;
293 
294  double error = 0.0;
295 
296  std::cout << "==========================================================" << std::endl
297  << "Checking variable " << var << " using error norm " << norm << " with tol " << tol << "...";
298 
299  if( norm == std::string("L2") )
300  {
301  error = exact_sol.l2_error(system_name, var);
302  }
303  else if( norm == std::string("H1") )
304  {
305  error = exact_sol.h1_error(system_name, var);
306  }
307  else
308  {
309  std::cerr << "ERROR: Invalid norm " << norm << std::endl;
310  exit(1);
311  }
312 
313  if( std::abs(error-exact_error) > tol )
314  {
315  return_flag = 1;
316 
317  std::cerr << "Tolerance exceeded for generic regression test!" << std::endl
318  << "tolerance = " << tol << std::endl
319  << "norm of error = " << error << std::endl
320  << "exact error = " << exact_error << std::endl
321  << "norm type = " << norm << std::endl
322  << "var = " << var << std::endl;
323  }
324  else
325  {
326  std::cout << "PASSED!" << std::endl
327  << "==========================================================" << std::endl;
328  }
329 
330  return return_flag;
331 }

Generated on Tue Dec 19 2017 12:47:29 for GRINS-0.8.0 by  doxygen 1.8.9.1