Detailed Description

Definition at line 38 of file ValSizeField.H.

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

	~ValSizeField () override

void	computeSizeField (vtkDataArray *da) override

void	setSizeFactor (double sf)

Static Public Member Functions
static std::vector< double >	computeValAtCell (vtkIdList cell_point_ids, vtkDataArray da)

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

static std::vector< double >	computeL2ValAtAllCells (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

◆ ValSizeField()

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

Definition at line 42 of file ValSizeField.C.

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

◆ ~ValSizeField()

NEM::ADP::ValSizeField::~ValSizeField ( )

inlineoverride

Definition at line 43 of file ValSizeField.H.

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

Member Function Documentation

◆ computeL2ValAtAllCells()

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

static

Definition at line 84 of file ValSizeField.C.

References computeValAtCell(), NEM::ADP::SizeFieldBase::da, and nemAux::l2_Norm().

Referenced by computeSizeField().

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

◆ computeSizeField()

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

overridevirtual

Implements NEM::ADP::SizeFieldBase.

Definition at line 100 of file ValSizeField.C.

References computeL2ValAtAllCells(), 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 = computeL2ValAtAllCells(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);
 }

◆ computeValAtAllCells()

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

static

Definition at line 69 of file ValSizeField.C.

References computeValAtCell(), and NEM::ADP::SizeFieldBase::da.

                                       {
   std::vector<std::vector<double>> result;
   result.reserve(ds->GetNumberOfCells());
 
   vtkCellIterator *it = ds->NewCellIterator();
   for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextCell()) {
     result.emplace_back(computeValAtCell(it->GetPointIds(), da));
   }
   it->Delete();
 
   return result;
 }

◆ computeValAtCell()

std::vector< double > NEM::ADP::ValSizeField::computeValAtCell	(	vtkIdList *	cell_point_ids,
		vtkDataArray *	da
	)

static

Definition at line 51 of file ValSizeField.C.

Referenced by computeL2ValAtAllCells(), and computeValAtAllCells().

                                                                      {
   int dim = da->GetNumberOfComponents();
   std::vector<double> values(dim, 0.0);
   int numPointsInCell = cell_point_ids->GetNumberOfIds();
   // compute value of data at center of cell
   for (int j = 0; j < numPointsInCell; ++j) {
     std::vector<double> comps(dim);
     da->GetTuple(cell_point_ids->GetId(j), comps.data());
     for (int i = 0; i < dim; ++i) {
       values[i] += comps[i] / numPointsInCell;
     }
   }
 
   return values;
 }

◆ 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 NEM::ADP::GradSizeField::computeSizeField(), and 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();
 }