NEM::ADP::Refine Class Reference

Detailed Description

Definition at line 42 of file Refine.H.

Public Member Functions
	Refine (meshBase *_mesh, const std::string &method, int arrayID, double dev_mult, bool maxIsmin, double edge_scale, const std::string &_ofname, double sizeFactor=1.0, int order=1)
	~Refine ()
void	run (bool transferData, bool bndryConstraint=false)

Private Member Functions
void	initUniform (double edge_scale)
void	initAdaptive (int arrayID, const std::string &method)
void	classifyBoundaries ()
void	unClassifyBoundaries ()

Private Attributes
meshBase *	mesh
MAd::pMesh	MadMesh
MAd::BackgroundSF *	bSF
MAd::PWLSField *	pwlSF
MAd::MeshAdapter *	adapter
std::string	ofname
MAd::pGEntity	bnd
bool	bndrConst

Constructor & Destructor Documentation

Refine()

NEM::ADP::Refine::Refine	(	meshBase *	_mesh,
		const std::string &	method,
		int	arrayID,
		double	dev_mult,
		bool	maxIsmin,
		double	edge_scale,
		const std::string &	_ofname,
		double	sizeFactor = 1.0,
		int	order = 1
	)

Definition at line 41 of file Refine.C.

References meshBase::generateSizeField(), initAdaptive(), initUniform(), and mesh.

    : mesh(_mesh), ofname(_ofname), bndrConst(false) {
  if (method != "uniform") {
    // creates sizeField
    mesh->generateSizeField(method, arrayID, dev_mult, maxIsmin, sizeFactor,
                            order);
    initAdaptive(arrayID, method);
  } else if (method == "uniform") {
    initUniform(edge_scale);
  }
}

~Refine()

NEM::ADP::Refine::~Refine

(

)

Definition at line 55 of file Refine.C.

References adapter, and MadMesh.

                {
  // destructor for adapter also destroys size field
  if (adapter) {
    delete adapter;
    adapter = nullptr;
  }
  /*
  if (bSF)
  {
    delete bSF;
    bSF = nullptr;
    std::cout << "here1" << std::endl;
  }
  if (pwlSF)
  {
    delete pwlSF;
    pwlSF = nullptr;
    std::cout << "here2" << std::endl;
  }
  */
  if (MadMesh) {
    MAd::M_delete(MadMesh);
    MadMesh = nullptr;
  }

  std::cout << "Refine destroyed" << std::endl;
}

Member Function Documentation

classifyBoundaries()

void NEM::ADP::Refine::classifyBoundaries ( )

private

Definition at line 225 of file Refine.C.

References bnd, and MadMesh.

Referenced by initAdaptive(), and initUniform().

                                {
  // finding and classifying boundary elements as 2d
  MadMesh->classify_unclassified_entities();
  MadMesh->destroyStandAloneEntities();
  bnd = (MAd::pGEntity)MAd::GM_faceByTag(MadMesh->model, 0);
  MadMesh->classify_grid_boundaries(bnd);
}

initAdaptive()

void NEM::ADP::Refine::initAdaptive ( int  arrayID, const std::string &  method  )

private

Definition at line 114 of file Refine.C.

References adapter, bSF, classifyBoundaries(), nemAux::Timer::elapsed(), meshBase::getDataSet(), MadMesh, mesh, pwlSF, nemAux::Timer::start(), nemAux::Timer::stop(), meshBase::unsetCellDataArray(), and meshBase::writeMSH().

Referenced by Refine().

                                                              {
  pwlSF = nullptr;
  auto *gMesh = new gmshMesh(mesh);
  gMesh->write("converted.msh", 2.0, false);

  vtkCellData *cd = mesh->getDataSet()->GetCellData();
  int i = 0;
  std::string array_name;
  if (cd) {
    array_name = mesh->getDataSet()->GetPointData()->GetArrayName(arrayID);
    if (method == "gradient")
      array_name.append("GradientSF");
    else if (method == "value")
      array_name.append("ValueSF");
    else if (method == "Z2 Error Estimator")
      array_name.append("Z2ErrorSF");
    for (i = 0; i < cd->GetNumberOfArrays(); ++i) {
      if (array_name == cd->GetArrayName(i)) break;
    }
    if (i == cd->GetNumberOfArrays()) {
      std::cerr << "Error: Did not find " << array_name << " in cell data set"
                << std::endl;
      exit(1);
    }
  }
  mesh->writeMSH("backgroundSF.msh", "cell", i, true);
  mesh->unsetCellDataArray(array_name);

  MAd::pGModel gmodel = nullptr;
  MadMesh = MAd::M_new(gmodel);
  MAd::M_load(MadMesh, "converted.msh");
  classifyBoundaries();

  bSF = new MAd::BackgroundSF("backgroundSF");
  bSF->loadData("backgroundSF.msh");

  std::cout << "\n \n Beginning Adapter Construction" << std::endl;
  // timing adapter construction
  nemAux::Timer T;
  T.start();
  // instantiating adapter with background sizeField
  adapter = new MAd::MeshAdapter(MadMesh, bSF);
  T.stop();
  std::cout << "Time for adapter construction (ms): " << T.elapsed() << "\n \n";
  std::cout << "Refine constructed" << std::endl;
}

initUniform()

void NEM::ADP::Refine::initUniform ( double  edge_scale )

private

Definition at line 83 of file Refine.C.

References adapter, bnd, bndrConst, classifyBoundaries(), nemAux::Timer::elapsed(), MadMesh, mesh, pwlSF, nemAux::Timer::start(), and nemAux::Timer::stop().

Referenced by Refine().

                                          {
  std::cout << "Uniform Refinement Selected" << std::endl;

  auto *gMesh = new gmshMesh(mesh);
  gMesh->write("converted.msh", 2.0, false);

  MAd::pGModel gmodel = nullptr;

  MadMesh = MAd::M_new(gmodel);
  MAd::M_load(MadMesh, "converted.msh");
  classifyBoundaries();
  // DISCRETE/PWLSF SIZEFIELD
  pwlSF = new MAd::PWLSField(MadMesh);
  // sets size as mean edge length squared for edges adjacent to given vertex
  pwlSF->setCurrentSize();
  pwlSF->scale(edge_scale);
  // timing adapter construction
  nemAux::Timer T;
  T.start();
  // instantiating adapter with linear sf
  adapter = new MAd::MeshAdapter(MadMesh, pwlSF);

  // TJW
  // option to constrain boundary edges when refining
  if (bndrConst) adapter->setConstraint(bnd);

  T.stop();
  std::cout << "Time for adapter construction (ms): " << T.elapsed() << "\n \n";
  std::cout << "Refine constructed" << std::endl;
}

run()

void NEM::ADP::Refine::run	(	bool	transferData,
		bool	bndryConstraint = false
	)

Definition at line 161 of file Refine.C.

References adapter, bnd, bndrConst, NEM::DRV::TransferDriver::CreateTransferObject(), meshBase::exportGmshToVtk(), meshBase::getNewArrayNames(), MadMesh, mesh, ofname, meshBase::report(), meshBase::setFileName(), unClassifyBoundaries(), and meshBase::write().

Referenced by meshBase::refineMesh().

                                                        {
  if (!adapter) {
    std::cerr << "Adapter hasn't been constructed!" << std::endl;
    exit(1);
  }
  // set boundary constraint flag
  bndrConst = bndryConstraint;
  // option to constrain boundary edges when refining
  if (bndrConst) adapter->setConstraint(bnd);
  // Output situation before refinement
  std::cout << "Statistics before refinement: " << std::endl;
  adapter->printStatistics(std::cout);

  // Adaptive refinement
  std::cout << "Refining the mesh ..." << std::endl;
  adapter->run();
  std::cout << "Statistics after refinement: " << std::endl;
  adapter->printStatistics(std::cout);

  // running Laplacian smoothing
  std::cout << "Optimizing the mesh" << std::endl;

  adapter->checkTheMesh(10);

  for (int i = 0; i < 1; ++i) {
    adapter->LaplaceSmoothing();
    adapter->splitLongestEdges();
    adapter->removeSlivers();
    adapter->optimiseEdgeLength();
    adapter->optimiseElementShape();
  }
  /* there is a fast laplace smoothing function available where instead of
   * computing the optimal position it uses the cavity center. The center is the
   * initial position passed to the routine "computeOptimalLocation" before it
   * calculates optimal. The optimal way is run by default. If we modify
   * line 714/718 in AdaptInterface.cc to laplOp->runFast we can use the
   * fast method */

  // Outputs final mesh
  std::cout << "Statistics after optimization: " << std::endl;
  adapter->printStatistics(std::cout);

  // unclassifying boundary elements for proper output
  unClassifyBoundaries();
  // writing refined mesh to file in msh format
  MAd::M_writeMsh(MadMesh, "refined.msh", 2);
  meshBase *refinedVTK = meshBase::exportGmshToVtk("refined.msh");

  // mesh->setCheckQuality(1);

  if (transferData) {
    // mesh->transfer(refinedVTK, "Consistent Interpolation");
    auto transfer = NEM::DRV::TransferDriver::CreateTransferObject(
        mesh, refinedVTK, "Consistent Interpolation");
    transfer->run(mesh->getNewArrayNames());
  }

  refinedVTK->setFileName(ofname);
  refinedVTK->report();
  refinedVTK->write();

  delete refinedVTK;
}

unClassifyBoundaries()

void NEM::ADP::Refine::unClassifyBoundaries ( )

private

Definition at line 233 of file Refine.C.

References MadMesh.

Referenced by run().

                                  {
  // unclassifying boundary elements for proper output
  MadMesh->unclassify_grid_boundaries();
}

Member Data Documentation

adapter

MAd::MeshAdapter* NEM::ADP::Refine::adapter

private

Definition at line 59 of file Refine.H.

Referenced by initAdaptive(), initUniform(), run(), and ~Refine().

bnd

MAd::pGEntity NEM::ADP::Refine::bnd

private

Definition at line 61 of file Refine.H.

Referenced by classifyBoundaries(), initUniform(), and run().

bndrConst

bool NEM::ADP::Refine::bndrConst

private

Definition at line 62 of file Refine.H.

Referenced by initUniform(), and run().

bSF

MAd::BackgroundSF* NEM::ADP::Refine::bSF

private

Definition at line 57 of file Refine.H.

Referenced by initAdaptive().

MadMesh

MAd::pMesh NEM::ADP::Refine::MadMesh

private

Definition at line 56 of file Refine.H.

Referenced by classifyBoundaries(), initAdaptive(), initUniform(), run(), unClassifyBoundaries(), and ~Refine().

mesh

meshBase* NEM::ADP::Refine::mesh

private

Definition at line 55 of file Refine.H.

Referenced by initAdaptive(), initUniform(), Refine(), and run().

ofname

std::string NEM::ADP::Refine::ofname

private

Definition at line 60 of file Refine.H.

Referenced by run().

pwlSF

MAd::PWLSField* NEM::ADP::Refine::pwlSF

private

Definition at line 58 of file Refine.H.

Referenced by initAdaptive(), and initUniform().

---

The documentation for this class was generated from the following files:

• Refine.H
• Refine.C