int main(int argc, char **argv)
{
//example_volume_mesher( "cube.off");
//exit(0);
int err, result;
string geomfile;
if (argc == 2) {
geomfile = argv[1];
}
else
{
cout << "Usage: executable geomfile (*.brep) " << endl;
if (argc != 1) return 1;
printf(" No file specified. Defaulting to: %s\n", "brick.brep");
geomfile = "brick.brep";
}
////////////////////////////////////////////////////////////////////////////
//Read the BRep geometric file
////////////////////////////////////////////////////////////////////////////
iGeom_Instance geom;
readGeometry(geomfile, geom);
////////////////////////////////////////////////////////////////////////////
// Generate the mesh.
////////////////////////////////////////////////////////////////////////////
EdgeMesher *edgeMesher = new EdgeMesher;
SurfaceMesher *surfMesher = SurfaceMesherFactory::getProduct("TetGen");
VolumeMesher *volMesher = VolumeMesherFactory::getProduct("TetGen");
GeomMesh geomesh;
geomesh.setGeometry(geom);
geomesh.edgeMesher = edgeMesher;
geomesh.surfMesher = surfMesher;
geomesh.volMesher = volMesher;
Discretize_Geometric_Model(geomesh);
////////////////////////////////////////////////////////////////////////////
//Save the mesh
////////////////////////////////////////////////////////////////////////////
const char *outfile = "brick.vtk";
int namelen = strlen(outfile);
const char *options = NULL;
int optlen = 0;
iMesh_Instance mesh = geomesh.mesh;
iBase_EntitySetHandle meshRootSet = geomesh.meshRootSet;
iMesh_save(mesh, meshRootSet, outfile, options, &err, namelen, optlen);
return 0;
}
inline iMesh::Error
iMesh::save( EntitySetHandle set,
const char* file_name,
const char* options )
{
int err, len = options ? strlen(options) : 0;
iMesh_save( mInstance, set, file_name, options, &err, strlen(file_name), len );
return (Error)err;
}
// This consistent interpolation example loads a linear quad mesh
// tagged with a scalar field and interpolates it along with the gradient
// pullback onto a delaunay tri mesh mesh. (Function domain = func_dmn,
// function range = func_rng )
int main(int argc, char* argv[])
{
// Setup communication.
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
if ( getDefaultComm<int>()->getRank() == 0 ) // Force scalar execution.
{
int error;
// The tensor template can be shared by both the range and
// domain value.
Teuchos::RCP<FOOD::TensorTemplate> tensor_template = Teuchos::rcp(
new FOOD::TensorTemplate(0, 1, FOOD::FOOD_REAL, Teuchos::null) );
// Need another one for the gradient. Here the gradient is a 3-vector.
Teuchos::RCP<FOOD::TensorTemplate> grad_tensor_template = Teuchos::rcp(
new FOOD::TensorTemplate(1, 3, FOOD::FOOD_REAL, Teuchos::null) );
// Set up the func_dmn mesh.
iMesh_Instance func_dmn_mesh;
iMesh_newMesh("", &func_dmn_mesh, &error, 0);
assert( iBase_SUCCESS == error );
iBase_EntitySetHandle func_dmn_root_set;
iMesh_getRootSet( func_dmn_mesh, &func_dmn_root_set, &error );
assert( iBase_SUCCESS == error );
std::string func_dmn_mesh_filename = "tagged_quad_flat_surf.vtk";
iMesh_load( func_dmn_mesh,
func_dmn_root_set,
&func_dmn_mesh_filename[0],
"",
&error,
(int) func_dmn_mesh_filename.size(),
0 );
assert( iBase_SUCCESS == error );
// Set up the func_dmn mesh field.
Teuchos::RCP<FOOD::Domain> func_dmn_domain = Teuchos::rcp(
new FOOD::Domain(func_dmn_mesh, func_dmn_root_set, FOOD::FOOD_MBCN) );
Teuchos::RCP< FOOD::DFuncKernel<double> > func_dmn_dfunckernel =
Teuchos::rcp( new FOOD::DFuncKernel<double>( iBase_FACE,
iMesh_QUADRILATERAL,
iBase_VERTEX,
iMesh_POINT,
FOOD::FOOD_CARTESIAN,
FOOD::FOOD_FEM,
FOOD::FOOD_HGRAD,
FOOD::FOOD_SHARDSCN,
2 ) );
Teuchos::RCP< FOOD::TensorField<double> > func_dmn_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_dmn_domain,
func_dmn_dfunckernel,
FOOD::FOOD_CARTESIAN,
tensor_template,
Teuchos::null,
"FUNC_DMN_FIELD" ) );
std::string func_dmn_tag_name = "domain";
iBase_TagHandle func_dmn_tag;
iMesh_getTagHandle( func_dmn_domain->getMesh(),
&func_dmn_tag_name[0],
&func_dmn_tag,
&error,
(int) func_dmn_tag_name.size() );
assert( iBase_SUCCESS == error );
func_dmn_field->attachToTagData( func_dmn_tag, error );
assert( iBase_SUCCESS == error );
// Set up the func_rng mesh.
iMesh_Instance func_rng_mesh;
iMesh_newMesh("", &func_rng_mesh, &error, 0);
assert( iBase_SUCCESS == error );
iBase_EntitySetHandle func_rng_root_set;
iMesh_getRootSet( func_rng_mesh, &func_rng_root_set, &error );
assert( iBase_SUCCESS == error );
std::string func_rng_mesh_filename = "tagged_delaunay_flat_surf.vtk";
iMesh_load( func_rng_mesh,
func_rng_root_set,
&func_rng_mesh_filename[0],
"",
&error,
(int) func_rng_mesh_filename.size(),
0 );
assert( iBase_SUCCESS == error );
// Set up the func_rng mesh field for function values.
Teuchos::RCP<FOOD::Domain> func_rng_domain = Teuchos::rcp(
new FOOD::Domain(func_rng_mesh, func_rng_root_set, FOOD::FOOD_MBCN) );
Teuchos::RCP< FOOD::DFuncKernel<double> > func_rng_dfunckernel =
Teuchos::rcp( new FOOD::DFuncKernel<double>( iBase_FACE,
iMesh_TRIANGLE,
iBase_VERTEX,
iMesh_POINT,
FOOD::FOOD_CARTESIAN,
FOOD::FOOD_FEM,
FOOD::FOOD_HGRAD,
FOOD::FOOD_SHARDSCN,
1 ) );
Teuchos::RCP< FOOD::TensorField<double> > func_rng_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_rng_domain,
func_rng_dfunckernel,
FOOD::FOOD_CARTESIAN,
tensor_template,
Teuchos::null,
"FUNC_RNG_FIELD" ) );
std::string func_rng_tag_name = "range";
iBase_TagHandle func_rng_tag;
iMesh_getTagHandle( func_rng_domain->getMesh(),
&func_rng_tag_name[0],
&func_rng_tag,
&error,
(int) func_rng_tag_name.size() );
assert( iBase_SUCCESS == error );
func_rng_field->attachToTagData( func_rng_tag, error );
assert( iBase_SUCCESS == error );
// Setup the gradient field.
Teuchos::RCP< FOOD::TensorField<double> > func_rng_grad_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_rng_domain,
func_rng_dfunckernel,
FOOD::FOOD_CARTESIAN,
grad_tensor_template,
Teuchos::null,
"FUNC_RNG_GRAD_FIELD" ) );
std::string func_rng_grad_tag_name = "grad_range";
iBase_TagHandle func_rng_grad_tag;
iMesh_getTagHandle( func_rng_domain->getMesh(),
&func_rng_grad_tag_name[0],
&func_rng_grad_tag,
&error,
(int) func_rng_grad_tag_name.size() );
assert( iBase_SUCCESS == error );
func_rng_grad_field->attachToTagData( func_rng_grad_tag, error );
assert( iBase_SUCCESS == error );
// Do interpolation.
FOOD::ConsistentScheme<double> fem_interp_val( func_dmn_field,
func_rng_field );
fem_interp_val.setup();
fem_interp_val.transferValueDF();
FOOD::ConsistentScheme<double> fem_interp_grad( func_dmn_field,
func_rng_grad_field );
fem_interp_grad.setup();
fem_interp_grad.transferGradDF();
// Write the interpolated mesh to file.
std::string interp_file = "flat_surf_output.vtk";
iMesh_save( func_rng_domain->getMesh(),
func_rng_domain->getMeshSet(),
&interp_file[0],
"",
&error,
(int) interp_file.size(),
0 );
assert( iBase_SUCCESS == error );
} // end rank 0
return 0;
}
