calculator.C File Reference

Go to the source code of this file.

Functions
void	usage_error (const char *progname)
template<typename T >
T	assert_argument (GetPot &cl, const std::string &argname, const char *progname, const T &defaultarg)
int	main (int argc, char **argv)

Function Documentation

assert_argument()

template<typename T >

T assert_argument	(	GetPot &	cl,
		const std::string &	argname,
		const char *	progname,
		const T &	defaultarg
	)

Definition at line 64 of file calculator.C.

{
  if (!cl.search(argname))
    {
      libMesh::err << ("No " + argname + " argument found!") << std::endl;
      usage_error(progname);
    }
  return cl.next(defaultarg);
}

References libMesh::err, and usage_error().

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 78 of file calculator.C.

{
  LibMeshInit init(argc, argv);
 
  GetPot cl(argc, argv);
 
  // In case the mesh file doesn't let us auto-infer dimension, we let
  // the user specify it on the command line
  const unsigned char requested_dim =
    cast_int<unsigned char>(cl.follow(3, "--dim"));
 
  // Load the old mesh from --inmesh filename.
  // Keep it serialized; we don't want elements on the new mesh to be
  // looking for data on old mesh elements that live off-processor.
  Mesh old_mesh(init.comm(), requested_dim);
 
  const std::string meshname =
    assert_argument(cl, "--inmesh", argv[0], std::string("mesh.xda"));
 
  old_mesh.read(meshname);
  std::cout << "Mesh:" << std::endl;
  old_mesh.print_info();
 
  // Create a new mesh for a new EquationSystems
  Mesh new_mesh(init.comm(), requested_dim);
  new_mesh.read(meshname);
 
  // Load the old solution from --insoln filename
  // Construct the new solution from the old solution's headers, so
  // that we get the system names and types, variable names and types,
  // etc.
  const std::string solnname =
    assert_argument(cl, "--insoln", argv[0], std::string("soln.xda"));
 
  EquationSystems old_es(old_mesh);
  EquationSystems new_es(new_mesh);
 
  XdrMODE read_mode;
 
  if (solnname.rfind(".xdr") < solnname.size())
    read_mode = DECODE;
  else if (solnname.rfind(".xda") < solnname.size())
    read_mode = READ;
  else
    libmesh_error_msg("Unrecognized file extension on " << solnname);
 
  old_es.read(solnname, read_mode,
              EquationSystems::READ_HEADER |
              EquationSystems::READ_DATA |
              EquationSystems::READ_ADDITIONAL_DATA |
              EquationSystems::READ_BASIC_ONLY);
 
  old_es.print_info();
 
 
  const unsigned int sysnum =
    cl.follow(0, "--insys");
 
  libmesh_assert_less(sysnum, old_es.n_systems());
 
  System & old_sys = old_es.get_system(sysnum);
  std::string current_sys_name = old_sys.name();
 
  libMesh::out << "Calculating with system " << current_sys_name << std::endl;
 
  L2System & new_sys = new_es.add_system<L2System>(current_sys_name);
 
  new_sys.time_solver =
    libmesh_make_unique<SteadySolver>(new_sys);
 
  new_sys.fe_family() =
    cl.follow(std::string("LAGRANGE"), "--family");
 
  new_sys.fe_order() =
    cl.follow(1, "--order");
 
  const std::string calcfunc =
    assert_argument(cl, "--calc", argv[0], std::string(""));
 
  ParsedFEMFunction<Number> goal_function(old_sys, calcfunc);
 
  new_sys.goal_func = goal_function.clone();
  new_sys.input_system = &old_sys;
 
  new_es.init();
 
  DiffSolver & solver = *(new_sys.time_solver->diff_solver().get());
  solver.quiet = false;
  solver.verbose = true;
  solver.relative_step_tolerance = 1e-10;
 
  new_sys.solve();
 
  // Write out the new solution file
  const std::string outsolnname = cl.follow(std::string("out_"+solnname), "--outsoln");
 
  new_es.write(outsolnname.c_str(),
               EquationSystems::WRITE_DATA |
               EquationSystems::WRITE_ADDITIONAL_DATA);
  libMesh::out << "Wrote solution " << outsolnname << std::endl;
 
  return 0;
}

References libMesh::EquationSystems::add_system(), assert_argument(), libMesh::ParsedFEMFunction< Output >::clone(), current_sys_name, libMesh::DECODE, L2System::fe_family(), L2System::fe_order(), libMesh::EquationSystems::get_system(), L2System::goal_func, libMesh::TriangleWrapper::init(), libMesh::EquationSystems::init(), L2System::input_system, libMesh::EquationSystems::n_systems(), libMesh::out, libMesh::EquationSystems::print_info(), libMesh::DiffSolver::quiet, libMesh::READ, libMesh::UnstructuredMesh::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::READ_ADDITIONAL_DATA, libMesh::EquationSystems::READ_BASIC_ONLY, libMesh::EquationSystems::READ_DATA, libMesh::EquationSystems::READ_HEADER, libMesh::DiffSolver::relative_step_tolerance, libMesh::FEMSystem::solve(), libMesh::DifferentiableSystem::time_solver, libMesh::DiffSolver::verbose, libMesh::EquationSystems::write(), libMesh::EquationSystems::WRITE_ADDITIONAL_DATA, and libMesh::EquationSystems::WRITE_DATA.

usage_error()

void usage_error

(

const char *

progname

)

Definition at line 46 of file calculator.C.

{
  libMesh::out << "Options: " << progname << '\n'
               << " --dim d               mesh dimension           [default: autodetect]\n"
               << " --inmesh    filename  input mesh file\n"
               << " --insoln    filename  input solution file\n"
               << " --calc      func      function to calculate\n"
               << " --insys     num       input system number      [default: 0]\n"
               << " --outsoln   filename  output solution file     [default: out_<insoln>]\n"
               << " --family    famname   output FEM family        [default: LAGRANGE]\n"
               << " --order     num       output FEM order         [default: 1]\n"
               << std::endl;
 
  exit(1);
}

References libMesh::out.

Referenced by assert_argument().