Detailed Description

Definition at line 38 of file GradSizeField.H.

Public Member Functions
	GradSizeField (vtkDataSet *_ds, int arrayID, double _dev_mult, bool _maxIsmin)

	~GradSizeField () override

void	computeSizeField (vtkDataArray *da) override

void	setSizeFactor (double sf)

Static Public Member Functions
static std::vector< double >	computeGradAtCell (vtkCell cell, vtkDataArray da)

static std::vector< double >	computeL2GradAtAllCells (vtkDataSet ds, vtkDataArray da)

static SizeFieldBase *	Create (vtkDataSet *_dataSet, const std::string &method, int arrayID, double _dev_mult, bool _maxIsmin, double _sizeFactor=1.0, int _order=1)

static std::unique_ptr< SizeFieldBase >	CreateUnique (vtkDataSet *_dataSet, const std::string &method, int arrayID, double _dev_mult, bool _maxIsmin, double _sizeFactor=1.0, int _order=1)

Protected Member Functions
void	mutateValues (std::vector< double > &values) const

Protected Attributes
vtkSmartPointer< vtkDataSet >	ds

double	dev_mult

bool	maxIsmin

vtkSmartPointer< vtkDataArray >	da

std::string	sfname

double	sizeFactor

Inherits NEM::ADP::SizeFieldBase.

Constructor & Destructor Documentation

◆ GradSizeField()

NEM::ADP::GradSizeField::GradSizeField	(	vtkDataSet *	_ds,
		int	arrayID,
		double	_dev_mult,
		bool	_maxIsmin
	)

Definition at line 44 of file GradSizeField.C.

     : SizeFieldBase(_ds, arrayID, _dev_mult, _maxIsmin, "GradientSF") {
   std::cout << "GradSizeField constructed" << std::endl;
 }

◆ ~GradSizeField()

NEM::ADP::GradSizeField::~GradSizeField ( )

inlineoverride

Definition at line 43 of file GradSizeField.H.

                             {
     std::cout << "GradSizeField destroyed" << std::endl;
   }

Member Function Documentation

◆ computeGradAtCell()

std::vector< double > NEM::ADP::GradSizeField::computeGradAtCell	(	vtkCell *	cell,
		vtkDataArray *	da
	)

static

Definition at line 52 of file GradSizeField.C.

Referenced by computeL2GradAtAllCells().

                                                                        {
   vtkIdList *point_ids = cell->GetPointIds();
   vtkIdType numPointsInCell = point_ids->GetNumberOfIds();
   int dim = da->GetNumberOfComponents();
 
   // populating array with point data of cell
   std::vector<double> values(dim * numPointsInCell);
   for (vtkIdType i = 0; i < numPointsInCell; ++i) {
     std::vector<double> comps(dim);
     da->GetTuple(point_ids->GetId(i), comps.data());
     for (int j = 0; j < dim; ++j) values[i * dim + j] = comps[j];
   }
   // # vals per vertex * # deriv directions (x,y,z)
   std::vector<double> gradient(dim * 3);
   std::vector<double> tmp(3, 0.0);
   // getting gradient of field over cell (Jacobian matrix for data)
   cell->Derivatives(0, tmp.data(), values.data(), dim, gradient.data());
   /* The Derivatives member for a cell computes the inverse of the Jacobian
    * transforming physical coordinates to parametric space, the derivatives of
    * the shape functions in parametric space and the interpolated values of
    * the derivatives of data for the cell in parametric space. It then
    * computes the matrix product of the inverse Jacobian with the interpolated
    * derivatives to transform them to physical coordinates. */
   return gradient;
 }

◆ computeL2GradAtAllCells()

std::vector< double > NEM::ADP::GradSizeField::computeL2GradAtAllCells	(	vtkDataSet *	ds,
		vtkDataArray *	da
	)

static

Definition at line 80 of file GradSizeField.C.

References computeGradAtCell(), nemAux::l2_Norm(), and NEM::MSH::New().

Referenced by computeSizeField().

                                                                              {
   std::vector<double> result;
   result.reserve(ds->GetNumberOfCells());
 
   vtkCellIterator *it = ds->NewCellIterator();
   vtkSmartPointer<vtkGenericCell> cell = vtkSmartPointer<vtkGenericCell>::New();
   for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextCell()) {
     it->GetCell(cell);
     result.emplace_back(nemAux::l2_Norm(computeGradAtCell(cell, da)));
   }
   it->Delete();
 
   return result;
 }

◆ computeSizeField()

void NEM::ADP::GradSizeField::computeSizeField ( vtkDataArray * da )

overridevirtual

Implements NEM::ADP::SizeFieldBase.

Definition at line 97 of file GradSizeField.C.

References computeL2GradAtAllCells(), NEM::ADP::SizeFieldBase::ds, NEM::ADP::SizeFieldBase::mutateValues(), NEM::MSH::New(), and NEM::ADP::SizeFieldBase::sfname.

                                                      {
   // populate vector with 2 norm of gradient/value of physical variable
   std::vector<double> values = computeL2GradAtAllCells(ds, da);
 
   if (values.empty()) {
     std::cerr << "size array hasn't been populated!" << std::endl;
     exit(1);
   }
 
   mutateValues(values);
 
   vtkSmartPointer<vtkDoubleArray> da2 = vtkSmartPointer<vtkDoubleArray>::New();
   da2->SetName(sfname.c_str());
   da2->SetNumberOfComponents(1);
   for (vtkIdType i = 0; i < ds->GetNumberOfCells(); ++i)
     da2->InsertNextTypedTuple(&values[i]);
   ds->GetCellData()->AddArray(da2);
 }

◆ Create()

SizeFieldBase * NEM::ADP::SizeFieldBase::Create	(	vtkDataSet *	_dataSet,
		const std::string &	method,
		int	arrayID,
		double	_dev_mult,
		bool	_maxIsmin,
		double	_sizeFactor = `1.0`,
		int	_order = `1`
	)

staticinherited

Definition at line 82 of file SizeFieldGen.C.

References NEM::ADP::SizeFieldBase::computeSizeField(), and NEM::ADP::SizeFieldBase::setSizeFactor().

Referenced by NEM::ADP::SizeFieldBase::CreateUnique().

                                                                     {
   SizeFieldBase *sf;
   if (method == "value") {
     sf = new ValSizeField(_dataSet, arrayID, _dev_mult, _maxIsmin);
   } else if (method == "gradient") {
     sf = new GradSizeField(_dataSet, arrayID, _dev_mult, _maxIsmin);
   } else if (method == "Z2 Error Estimator") {
     sf = new Z2ErrorSizeField(_dataSet, arrayID, _order);
   } else {
     std::cerr << "Specified method " << method << " is not supported\n";
     std::cerr << "Available methods are gradient, value and error" << std::endl;
     exit(1);
   }
   sf->setSizeFactor(sizeFactor);
   sf->computeSizeField(_dataSet->GetPointData()->GetArray(arrayID));
   return sf;
 }

◆ CreateUnique()

std::unique_ptr< SizeFieldBase > NEM::ADP::SizeFieldBase::CreateUnique	(	vtkDataSet *	_dataSet,
		const std::string &	method,
		int	arrayID,
		double	_dev_mult,
		bool	_maxIsmin,
		double	_sizeFactor = `1.0`,
		int	_order = `1`
	)

staticinherited

Definition at line 103 of file SizeFieldGen.C.

References NEM::ADP::SizeFieldBase::Create().

Referenced by meshBase::generateSizeField().

                                                                       {
   return std::unique_ptr<SizeFieldBase>(SizeFieldBase::Create(
       _dataSet, method, arrayID, _dev_mult, _maxIsmin, _sizeFactor, _order));
 }

◆ mutateValues()

void NEM::ADP::SizeFieldBase::mutateValues ( std::vector< double > & values ) const

protectedinherited

Definition at line 112 of file SizeFieldGen.C.

References nemAux::cellsToRefineMaxdev(), NEM::ADP::SizeFieldBase::dev_mult, NEM::ADP::SizeFieldBase::ds, nemAux::getMeanStdev(), nemAux::getMinMax(), nemAux::hasZero(), NEM::ADP::SizeFieldBase::maxIsmin, nemAux::reciprocal_vec(), nemAux::scale_vec_to_range(), and NEM::ADP::SizeFieldBase::sizeFactor.

Referenced by computeSizeField(), and NEM::ADP::ValSizeField::computeSizeField().

                                                                 {
   std::cout << "Size Factor = " << sizeFactor << std::endl;
   // get circumsphere diameter of all cells
   std::vector<double> lengths(ds->GetNumberOfCells());
   for (vtkIdType i = 0; i < ds->GetNumberOfCells(); ++i)
     lengths[i] = std::sqrt(ds->GetCell(i)->GetLength2());
   // find minmax of diameters
   std::vector<double> lengthminmax = nemAux::getMinMax(lengths);
   // redefine minmax values for appropriate size definition reference
   if (maxIsmin)
     lengthminmax[1] = lengthminmax[0];
   else
     lengthminmax[1] *= 0.65;
   lengthminmax[0] -= lengthminmax[0] / 2.;
 
   // min/max length
   std::cout << "Min Elm Length Scale : " << lengthminmax[0] << "\n"
             << "Max Elm Length Scale : " << lengthminmax[1] << std::endl;
   // get mean and stdev of values
   std::vector<double> meanStdev = nemAux::getMeanStdev(values);
   // get bool array of which cells to refine based on multiplier of stdev
   // std::vector<bool> cells2Refine
   //    = nemAux::cellsToRefine(values, meanStdev[0] + meanStdev[1] * dev_mult);
   // std::vector<bool> cells2Refine
   //    = nemAux::cellsToRefineStdev(values, meanStdev[0],
   //                                 meanStdev[1] * dev_mult);
   std::vector<bool> cells2Refine =
       nemAux::cellsToRefineMaxdev(values, dev_mult);
   // normalize values by mean
   std::vector<double> values_norm = (1. / meanStdev[0]) * values;
   // take the reciprocal of values for size definition (high value -> smaller
   // size)
   if (!nemAux::hasZero(values)) nemAux::reciprocal_vec(values);
 
   // scale values to min max circumsphere diam of cells
   // now, values represents a size field
   std::vector<double> valuesMinMax = nemAux::getMinMax(values);
   nemAux::scale_vec_to_range(values, valuesMinMax, lengthminmax);
 
   // setting sizes (values) to f*max element diam based on return of
   // cellsToRefine function
   std::ofstream elmLst;
   elmLst.open("refineCellList.csv");
   if (!elmLst.good()) {
     std::cerr << "Error opening the stream for refinement list." << std::endl;
     exit(1);
   }
   bool isFirstElmIdx = true;
   for (int i = 0; i < values.size(); ++i) {
     if (!cells2Refine[i])
       values[i] = lengthminmax[1];  // if cell shouldn't be refined, size set to
                                     // min of diams
     else {
       if (isFirstElmIdx) {
         elmLst << i;
         isFirstElmIdx = false;
       } else
         elmLst << "," << i;
       values[i] = sizeFactor * values[i];
     }
   }
   elmLst.close();
 }