Detailed Description

Definition at line 38 of file Z2ErrorSizeField.H.

Public Member Functions
	Z2ErrorSizeField (vtkDataSet *_ds, int arrayID, int _order)

	~Z2ErrorSizeField () override

double	computeNodalError (int arrayID) const

void	computeSizeField (vtkDataArray *da) override

int	getOrder () const

void	setOrder (int _order)

void	setSizeFactor (double sf)

Static Public Member Functions
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

Private Attributes
int	order

Inherits NEM::ADP::SizeFieldBase.

Constructor & Destructor Documentation

◆ Z2ErrorSizeField()

NEM::ADP::Z2ErrorSizeField::Z2ErrorSizeField	(	vtkDataSet *	_ds,
		int	arrayID,
		int	_order
	)

Definition at line 39 of file Z2ErrorSizeField.C.

     : SizeFieldBase(_ds, arrayID, 0.0, false, "Z2ErrorSF"), order(_order) {
   std::cout << "Z2ErrorSizeField constructed" << std::endl;
 }

◆ ~Z2ErrorSizeField()

NEM::ADP::Z2ErrorSizeField::~Z2ErrorSizeField ( )

inlineoverride

Definition at line 43 of file Z2ErrorSizeField.H.

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

Member Function Documentation

◆ computeNodalError()

double NEM::ADP::Z2ErrorSizeField::computeNodalError ( int arrayID ) const

Definition at line 44 of file Z2ErrorSizeField.C.

References PatchRecovery::computeNodalError(), NEM::ADP::SizeFieldBase::ds, and order.

Referenced by computeSizeField().

                                                             {
   std::vector<int> arrayIDs(1);
   arrayIDs[0] = arrayID;
   std::unique_ptr<PatchRecovery> recoverObj =
       std::unique_ptr<PatchRecovery>(new PatchRecovery(ds, order, arrayIDs));
   return recoverObj->computeNodalError()[0][0];
 }

◆ computeSizeField()

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

overridevirtual

Implements NEM::ADP::SizeFieldBase.

Definition at line 52 of file Z2ErrorSizeField.C.

References computeNodalError(), NEM::ADP::SizeFieldBase::ds, NEM::MSH::New(), order, NEM::ADP::SizeFieldBase::sfname, and NEM::ADP::SizeFieldBase::sizeFactor.

                                                         {
   int arrayID;
   ds->GetPointData()->GetArray(da->GetName(), arrayID);
   double aveError = computeNodalError(arrayID) / ds->GetNumberOfCells();
 
   std::string errorName = da->GetName();
   errorName += "ErrorIntegral";
 
   vtkSmartPointer<vtkDataArray> errorIntegrals =
       ds->GetCellData()->GetArray(errorName.c_str());
   vtkSmartPointer<vtkDataArray> nodeSizes =
       ds->GetPointData()->GetArray("nodeSizes");
 
   std::vector<double> sizeField;
   sizeField.reserve(ds->GetNumberOfCells());
 
   vtkCellIterator *it = ds->NewCellIterator();
   vtkSmartPointer<vtkGenericCell> cell = vtkSmartPointer<vtkGenericCell>::New();
   for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextCell()) {
     double interpSize = 0.0;
     it->GetCell(cell);
 
     double center[3];
     auto *weights = new double[cell->GetNumberOfPoints()];
     int subId;    // dummy
     double x[3];  // dummy
     cell->GetParametricCenter(center);
     cell->EvaluateLocation(subId, center, x, weights);
 
     for (int j = 0; j < cell->GetNumberOfPoints(); ++j) {
       int pntID = cell->GetPointId(j);
       double size[1];
       nodeSizes->GetTuple(pntID, size);
       interpSize += size[0] * weights[j];
     }
     delete[] weights;
 
     double error[1];
     errorIntegrals->GetTuple(it->GetCellId(), error);
     sizeField.emplace_back(
         interpSize / (std::pow(error[0] / aveError, 1.0 / order)) * sizeFactor);
   }
   it->Delete();
 
   vtkSmartPointer<vtkDoubleArray> da2 = vtkSmartPointer<vtkDoubleArray>::New();
   da2->SetName(sfname.c_str());
   da2->SetNumberOfComponents(1);
   for (vtkIdType i = 0; i < ds->GetNumberOfCells(); ++i)
     da2->InsertNextTypedTuple(&sizeField[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));
 }

◆ getOrder()

int NEM::ADP::Z2ErrorSizeField::getOrder ( ) const

inline

Definition at line 55 of file Z2ErrorSizeField.H.

55 { return order; }

NEM::ADP::Z2ErrorSizeField::order

int order

Definition: Z2ErrorSizeField.H:59

◆ 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 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();
 }