projection.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)
Number	fptr (const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)
Gradient	gptr (const Point &p, const Parameters &, const std::string &libmesh_dbg_var(sys_name), const std::string &unknown_name)
int	main (int argc, char **argv)

Variables
std::string	current_sys_name
std::map< std::string, MeshFunction * >	mesh_functions

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 59 of file projection.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().

fptr()

Number fptr	(	const Point &	p,
		const Parameters &	,
		const std::string &	libmesh_dbg_varsys_name,
		const std::string &	unknown_name
	)

Definition at line 80 of file projection.C.

{
  libmesh_assert_equal_to (sys_name, current_sys_name);
  libmesh_assert(mesh_functions.count(unknown_name));
  libmesh_assert(mesh_functions[unknown_name]);
 
  MeshFunction & meshfunc = *mesh_functions[unknown_name];
 
  return meshfunc(p);
}

References current_sys_name, libMesh::libmesh_assert(), and mesh_functions.

Referenced by libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::System::attach_assemble_function(), libMesh::System::attach_constraint_function(), libMesh::DiscontinuityMeasure::attach_essential_bc_function(), libMesh::ExactErrorEstimator::attach_exact_value(), libMesh::ExactSolution::attach_exact_value(), libMesh::KellyErrorEstimator::attach_flux_bc_function(), libMesh::System::attach_init_function(), libMesh::System::attach_QOI_derivative(), libMesh::System::attach_QOI_function(), libMesh::FrequencySystem::attach_solve_function(), libMesh::System::boundary_project_solution(), libMesh::System::boundary_project_vector(), main(), libMesh::System::project_solution(), and libMesh::System::project_vector().

gptr()

Gradient gptr	(	const Point &	p,
		const Parameters &	,
		const std::string &	libmesh_dbg_varsys_name,
		const std::string &	unknown_name
	)

Definition at line 95 of file projection.C.

{
  libmesh_assert_equal_to (sys_name, current_sys_name);
  libmesh_assert(mesh_functions.count(unknown_name));
  libmesh_assert(mesh_functions[unknown_name]);
 
  MeshFunction & meshfunc = *mesh_functions[unknown_name];
 
  return meshfunc.gradient(p);
}

References current_sys_name, libMesh::MeshFunction::gradient(), libMesh::libmesh_assert(), and mesh_functions.

Referenced by libMesh::ExactErrorEstimator::attach_exact_deriv(), libMesh::ExactSolution::attach_exact_deriv(), libMesh::System::boundary_project_solution(), libMesh::System::boundary_project_vector(), main(), libMesh::System::project_solution(), and libMesh::System::project_vector().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 110 of file projection.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.
  ReplicatedMesh 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 << "Old Mesh:" << std::endl;
  old_mesh.print_info();
 
  // Load the new mesh from --outmesh filename
  Mesh new_mesh(init.comm(), requested_dim);
 
  const std::string outmeshname = cl.follow(std::string("out_"+meshname), "--outmesh");
 
  new_mesh.read(outmeshname);
  std::cout << "New Mesh:" << std::endl;
  new_mesh.print_info();
 
  // 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);
 
  new_es.read(solnname, read_mode,
              EquationSystems::READ_HEADER |
              EquationSystems::READ_BASIC_ONLY);
 
  old_es.print_info();
 
  unsigned int n_systems = old_es.n_systems();
  libmesh_assert_equal_to (new_es.n_systems(), n_systems);
 
  // For each system, serialize the solution so we can project it onto
  // a potentially-very-different partitioning
  for (unsigned int i = 0; i != n_systems; ++i)
    {
      System & old_sys = old_es.get_system(i);
      current_sys_name = old_sys.name();
 
      libMesh::out << "Projecting system " << current_sys_name << std::endl;
 
      libmesh_assert (new_es.has_system(current_sys_name));
 
      System & new_sys = new_es.get_system(current_sys_name);
      unsigned int n_vars = old_sys.n_vars();
      libmesh_assert_equal_to (new_sys.n_vars(), n_vars);
 
      std::unique_ptr<NumericVector<Number>> comparison_soln =
        NumericVector<Number>::build(old_sys.comm());
      std::vector<Number> global_soln;
      old_sys.update_global_solution(global_soln);
      comparison_soln->init(old_sys.solution->size(), true, SERIAL);
      (*comparison_soln) = global_soln;
 
      // For each variable, construct a MeshFunction returning that
      // variable's value
      for (unsigned int j = 0; j != n_vars; ++j)
        {
          libMesh::out << " with variable " << old_sys.variable_name(j) << std::endl;
 
          MeshFunction * mesh_func =
            new MeshFunction(old_es, *comparison_soln,
                             old_sys.get_dof_map(), j);
          mesh_func->init();
          mesh_functions[old_sys.variable_name(j)] = mesh_func;
        }
 
      // Project all variables to the new system
      new_sys.project_solution(fptr, gptr, old_es.parameters);
 
      // Clean up the MeshFunctions here so we don't bloat memory
      for (unsigned int j = 0; j != n_vars; ++j)
        delete mesh_functions[old_sys.variable_name(j)];
    }
 
  // 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 assert_argument(), libMesh::NumericVector< T >::build(), libMesh::ParallelObject::comm(), current_sys_name, libMesh::DECODE, fptr(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_system(), gptr(), libMesh::EquationSystems::has_system(), libMesh::TriangleWrapper::init(), libMesh::MeshFunction::init(), libMesh::libmesh_assert(), mesh_functions, libMesh::EquationSystems::n_systems(), n_vars, libMesh::System::n_vars(), libMesh::System::name(), libMesh::out, libMesh::EquationSystems::parameters, libMesh::EquationSystems::print_info(), 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::SERIAL, libMesh::System::solution, libMesh::System::update_global_solution(), libMesh::System::variable_name(), libMesh::EquationSystems::write(), libMesh::EquationSystems::WRITE_ADDITIONAL_DATA, and libMesh::EquationSystems::WRITE_DATA.

usage_error()

void usage_error

(

const char *

progname

)

Definition at line 44 of file projection.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"
               << " --outmesh filename    output mesh file         [default: out_<inmesh>]\n"
               << " --outsoln filename    output solution file     [default: out_<insoln>]\n"
               << std::endl;
 
  exit(1);
}

References libMesh::out.

Referenced by assert_argument().

Variable Documentation

current_sys_name

std::string current_sys_name

Definition at line 76 of file projection.C.

Referenced by fptr(), gptr(), and main().

mesh_functions

std::map<std::string, MeshFunction *> mesh_functions

Definition at line 77 of file projection.C.

Referenced by fptr(), gptr(), and main().