OrderOfAccuracy Class Reference

The OrderOfAccuracy class computes the grid convergence index (GCI) given three successively refined meshes. More...

Detailed Description

The GCI is particularly robust since it accounts for the order of convergence as well as the grid refinement ratio.

If a vector field is being analyzed, a GCI will be generated for each component.

For more information see: Roache, P.J. Verification and Validation in Compuational Science and Engineering, Hermosa Publishers, Albuquerque, New Mexico, 1998

Definition at line 54 of file OrderOfAccuracy.H.

Public Member Functions
	OrderOfAccuracy (meshBase *_f3, meshBase *_f2, meshBase *_f1, std::vector< int > _arrayIDs, std::string transferType="Consistent Interpolation", double targetGCI=1.1)
	~OrderOfAccuracy ()=default
std::vector< std::vector< double > >	computeOrderOfAccuracy ()
	Compute order of accuracy. More...
std::vector< std::vector< double > >	computeGCI_21 ()
	Compute the GCI with respect to the finer and finest grids. More...
std::vector< std::vector< double > >	computeGCI_32 ()
	Compute the GCI with respect to the coarsest and finer grids. More...
std::vector< std::vector< double > >	computeResolution (double gciStar)
	Compute the grid resolution required to obtain the desired gci/level of accuracy for each component across all mesh fields. More...
void	computeRichardsonExtrapolation ()
std::vector< std::vector< double > >	getOrderOfAccuracy () const
	Returns order of accuracy for each component of each field. More...
std::vector< std::vector< double > >	checkAsymptoticRange ()
	Check if grids are in asymptotic range of convergence based on the computed GCIs (GCI_32 and GCI_21). More...
void	computeMeshWithResolution (double gciStar, const std::string &ofname)
	Refine the coarsest mesh based on the target GCI, write to file with name ofname. More...
std::vector< std::vector< double > >	computeDiff (meshBase *mesh, const std::vector< std::string > &newArrNames)
std::vector< std::vector< double > >	getDiffF2F1 () const
double	getTargetGCI () const

Private Attributes
meshBase *	f3
meshBase *	f2
meshBase *	f1
	meshes from least to most refined (f3 - coarsest, f2 - finer, f1 - finest) More...
const std::vector< int >	arrayIDs
	array ids for arrays to be considered in analysis More...
std::vector< int >	diffIDs
	array ids for differences^2 in solutions between meshes More...
std::vector< int >	relEIDs
	array ids for integral of solutions on the most refined mesh, used in computing relative discretization error More...
std::vector< int >	realDiffIDs
	array ids for actual difference data More...
std::vector< std::string >	f3ArrNames
std::vector< std::string >	f2ArrNames
	names of data arrays transferred from f3 to f2 and from f2 to f1 More...
double	r21
double	r32
	effective grid refinement ratios More...
std::vector< std::vector< double > >	diffF3F2
	L2 norm of the difference in solution between f3 and f2. More...
std::vector< std::vector< double > >	diffF2F1
	L2 norm of the difference in solution between f2 and f1. More...
std::vector< std::vector< double > >	GCI_32
	GCIs with respect to the coarse mesh (f3) More...
std::vector< std::vector< double > >	GCI_21
	GCIs with respect to the finer mesh (f2) More...
std::vector< std::vector< double > >	orderOfAccuracy
	Order of accuracy (p) with respect to refinements f3-f2-f1. More...
double	targetGCI

Constructor & Destructor Documentation

OrderOfAccuracy()

OrderOfAccuracy::OrderOfAccuracy	(	meshBase *	_f3,
		meshBase *	_f2,
		meshBase *	_f1,
		std::vector< int >	_arrayIDs,
		std::string	transferType = "Consistent Interpolation",
		double	targetGCI = 1.1
	)

Definition at line 36 of file OrderOfAccuracy.C.

References arrayIDs, computeDiff(), NEM::DRV::TransferDriver::CreateTransferObject(), diffF2F1, diffF3F2, diffIDs, f1, f2, f2ArrNames, f3, f3ArrNames, meshBase::getDataSet(), meshBase::getNumberOfPoints(), r21, r32, realDiffIDs, and relEIDs.

    : f3(_f3),
      f2(_f2),
      f1(_f1),
      arrayIDs(std::move(_arrayIDs)),
      targetGCI(targetGCI) {
  // set names for array from coarse mesh to be transferred to fine
  int numArr = arrayIDs.size();

  f3ArrNames.resize(numArr);
  f2ArrNames.resize(numArr);
  diffIDs.resize(numArr);
  relEIDs.resize(numArr);
  realDiffIDs.resize(numArr);

  for (int i = 0; i < numArr; ++i) {
    // get names from coarsest mesh
    std::string name =
        f3->getDataSet()->GetPointData()->GetArrayName(arrayIDs[i]);
    std::string coarseName = name + "f3";
    std::string fineName = name + "f2";
    f3ArrNames[i] = coarseName;
    f2ArrNames[i] = fineName;
  }

  auto f3f2Transfer =
      NEM::DRV::TransferDriver::CreateTransferObject(f3, f2, transferType);
  f3f2Transfer->transferPointData(arrayIDs, f3ArrNames);
  auto f2f1Transfer =
      NEM::DRV::TransferDriver::CreateTransferObject(f2, f1, transferType);
  f2f1Transfer->transferPointData(arrayIDs, f2ArrNames);

  diffF3F2 = computeDiff(f2, f3ArrNames);
  diffF2F1 = computeDiff(f1, f2ArrNames);

  // TODO: Double-check the integer division below.
  r21 = pow(f1->getNumberOfPoints() / f2->getNumberOfPoints(), 1. / 3.);
  r32 = pow(f2->getNumberOfPoints() / f3->getNumberOfPoints(), 1. / 3.);
  std::cout << "Refinement ratio from 2-to-1 is " << r21 << " "
            << " and from 3-to-2 is " << r32 << std::endl;
}

~OrderOfAccuracy()

OrderOfAccuracy::~OrderOfAccuracy ( )

default

Member Function Documentation

checkAsymptoticRange()

std::vector< std::vector< double > > OrderOfAccuracy::checkAsymptoticRange

(

)

We are within asymptotic range if all values are close to 1

Returns

Weighted ratio of GCIs for each component of each field in grids

Definition at line 185 of file OrderOfAccuracy.C.

References computeGCI_21(), computeGCI_32(), GCI_21, GCI_32, orderOfAccuracy, and r21.

Referenced by computeMeshWithResolution().

                                                                   {
  if (GCI_21.empty()) computeGCI_21();
  if (GCI_32.empty()) computeGCI_32();
  std::vector<std::vector<double>> ratios(GCI_21.size());
  for (int i = 0; i < GCI_21.size(); ++i) {
    ratios[i].resize(GCI_21[i].size());
    for (int j = 0; j < GCI_21[i].size(); ++j) {
      ratios[i][j] =
          GCI_32[i][j] / (pow(r21, orderOfAccuracy[i][j]) * GCI_21[i][j]);
    }
  }
  return ratios;
}

computeDiff()

std::vector< std::vector< double > > OrderOfAccuracy::computeDiff	(	meshBase *	mesh,
		const std::vector< std::string > &	newArrNames
	)

Definition at line 263 of file OrderOfAccuracy.C.

References arrayIDs, diffIDs, meshBase::getDataSet(), meshBase::getNumberOfPoints(), id, meshBase::integrateOverMesh(), NEM::MSH::New(), realDiffIDs, and relEIDs.

Referenced by OrderOfAccuracy().

                                                             {
  // diff is computed across multiple data items, specified by arrayIDs
  int numArr = arrayIDs.size();
  std::vector<vtkSmartPointer<vtkDoubleArray>> fineDatas(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> coarseDatas(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> diffDatas(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> fineDatasSqr(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> realDiffDatas(numArr);

  vtkSmartPointer<vtkPointData> finePD = mesh->getDataSet()->GetPointData();

  std::vector<std::string> names(numArr);
  std::vector<std::string> names2(numArr);
  std::vector<std::string> names3(numArr);

  std::string diffSqrName, sqrName, diffName;
  for (int id = 0; id < numArr; ++id) {
    fineDatas[id] =
        vtkDoubleArray::SafeDownCast(finePD->GetArray(arrayIDs[id]));
    coarseDatas[id] =
        vtkDoubleArray::SafeDownCast(finePD->GetArray(newArrNames[id].c_str()));

    // initialize
    vtkSmartPointer<vtkDoubleArray> diffData =
        vtkSmartPointer<vtkDoubleArray>::New();
    vtkSmartPointer<vtkDoubleArray> fineDataSqr =
        vtkSmartPointer<vtkDoubleArray>::New();
    vtkSmartPointer<vtkDoubleArray> realDiffData =
        vtkSmartPointer<vtkDoubleArray>::New();

    diffData->SetNumberOfComponents(fineDatas[id]->GetNumberOfComponents());
    diffData->SetNumberOfTuples(mesh->getNumberOfPoints());
    std::string name(finePD->GetArrayName(arrayIDs[id]));
    name += "DiffSqr";
    names[id] = name;
    diffData->SetName(name.c_str());
    diffDatas[id] = diffData;

    fineDataSqr->SetNumberOfComponents(fineDatas[id]->GetNumberOfComponents());
    fineDataSqr->SetNumberOfTuples(mesh->getNumberOfPoints());
    std::string name2(finePD->GetArrayName(arrayIDs[id]));
    name2 += "Sqr";
    names2[id] = name2;
    fineDataSqr->SetName(name2.c_str());
    fineDatasSqr[id] = fineDataSqr;

    realDiffData->SetNumberOfComponents(fineDatas[id]->GetNumberOfComponents());
    realDiffData->SetNumberOfTuples(mesh->getNumberOfPoints());
    std::string name3(finePD->GetArrayName(arrayIDs[id]));
    name3 += "Diff";
    names3[id] = name3;
    realDiffData->SetName(name3.c_str());
    realDiffDatas[id] = realDiffData;
  }

  int numPts = mesh->getNumberOfPoints();
  for (int id = 0; id < numArr; ++id) {
    auto fineData = fineDatas[id];
    auto coarseData = coarseDatas[id];
    auto diffData = diffDatas[id];
    auto fineDataSqr = fineDatasSqr[id];
    auto realDiffData = realDiffDatas[id];

    int numComps = fineDatas[id]->GetNumberOfComponents();

    double *fine_comps = new double[numComps];
    double *coarse_comps = new double[numComps];
    double *diff = new double[numComps];
    double *fsqr = new double[numComps];
    double *realdiff = new double[numComps];

    for (int i = 0; i < numPts; ++i) {
      fineData->GetTuple(i, fine_comps);
      coarseData->GetTuple(i, coarse_comps);

      for (int j = 0; j < numComps; ++j) {
        double error = coarse_comps[j] - fine_comps[j];
        diff[j] = error * error;
        fsqr[j] = fine_comps[j] * fine_comps[j];
        realdiff[j] = fine_comps[j] - coarse_comps[j];
      }

      diffData->SetTuple(i, diff);
      fineDataSqr->SetTuple(i, fsqr);
      realDiffData->SetTuple(i, realdiff);
    }
    delete[] fine_comps;
    delete[] coarse_comps;
    delete[] diff;
    delete[] fsqr;
    delete[] realdiff;
  }

  for (int id = 0; id < numArr; ++id) {
    finePD->AddArray(diffDatas[id]);
    finePD->GetArray(names[id].c_str(), diffIDs[id]);
    finePD->AddArray(fineDatasSqr[id]);
    finePD->GetArray(names2[id].c_str(), relEIDs[id]);
    finePD->AddArray(realDiffDatas[id]);
    finePD->GetArray(names3[id].c_str(), realDiffIDs[id]);
  }

  std::vector<std::vector<double>> diff_integral(
      mesh->integrateOverMesh(diffIDs));
  for (auto &&i : diff_integral) {
    for (double &j : i) {
      j = std::sqrt(j);
      std::cout << j << " ";
    }
    std::cout << std::endl;
  }
  return diff_integral;
}

computeGCI_21()

std::vector< std::vector< double > > OrderOfAccuracy::computeGCI_21

(

)

Returns

GCI for each component of each field transferred from the finer mesh (f2) to the finest mesh (f1).

Definition at line 105 of file OrderOfAccuracy.C.

References computeOrderOfAccuracy(), diffF2F1, f1, GCI_21, meshBase::integrateOverMesh(), orderOfAccuracy, r21, and relEIDs.

Referenced by checkAsymptoticRange().

                                                            {
  if (GCI_21.empty()) {
    if (orderOfAccuracy.empty()) {
      computeOrderOfAccuracy();
    }
    std::vector<std::vector<double>> f1L2(f1->integrateOverMesh(relEIDs));
    GCI_21.resize(orderOfAccuracy.size());
    for (int i = 0; i < orderOfAccuracy.size(); ++i) {
      GCI_21[i].resize(orderOfAccuracy[i].size());
      for (int j = 0; j < orderOfAccuracy[i].size(); ++j) {
        double relativeError = diffF2F1[i][j] / std::sqrt(f1L2[i][j]);
        GCI_21[i][j] =
            1.25 * relativeError / (pow(r21, orderOfAccuracy[i][j]) - 1);
      }
    }
  }
  return GCI_21;
}

computeGCI_32()

std::vector< std::vector< double > > OrderOfAccuracy::computeGCI_32

(

)

Returns

GCI for each component of each field transferred from the coarse mesh (f3) to the finer mesh (f2).

Definition at line 124 of file OrderOfAccuracy.C.

References computeOrderOfAccuracy(), diffF3F2, f2, GCI_32, meshBase::integrateOverMesh(), orderOfAccuracy, r32, and relEIDs.

Referenced by checkAsymptoticRange(), and computeResolution().

                                                            {
  if (GCI_32.empty()) {
    if (orderOfAccuracy.empty()) {
      computeOrderOfAccuracy();
    }
    std::vector<std::vector<double>> f2L2(f2->integrateOverMesh(relEIDs));
    GCI_32.resize(orderOfAccuracy.size());
    for (int i = 0; i < orderOfAccuracy.size(); ++i) {
      GCI_32[i].resize(orderOfAccuracy[i].size());
      for (int j = 0; j < orderOfAccuracy[i].size(); ++j) {
        double relativeError = diffF3F2[i][j] / std::sqrt(f2L2[i][j]);
        GCI_32[i][j] =
            1.25 * relativeError / (pow(r32, orderOfAccuracy[i][j]) - 1);
      }
    }
  }
  return GCI_32;
}

computeMeshWithResolution()

void OrderOfAccuracy::computeMeshWithResolution	(	double	gciStar,
		const std::string &	ofname
	)

Parameters

gciStar	target GCI
ofname	refined mesh filename

Definition at line 156 of file OrderOfAccuracy.C.

References arrayIDs, checkAsymptoticRange(), computeResolution(), computeRichardsonExtrapolation(), meshBase::Create(), NEM::DRV::TransferDriver::CreateTransferObject(), f3, nemAux::flatten(), meshBase::refineMesh(), and meshBase::write().

                                                                         {
  std::vector<std::vector<double>> ratios(checkAsymptoticRange());
  for (const auto &ratio : ratios) {
    for (double j : ratio) {
      if (std::abs(j - 1) > 1) {
        std::cerr
            << "WARNING: Solutions are not in the asymptotic convergence range"
            << std::endl;
      }
    }
  }

  std::vector<double> resolution = nemAux::flatten(computeResolution(gciStar));
  auto minmax = std::minmax_element(resolution.begin(), resolution.end());
  double ave = (*minmax.first + *minmax.second) / 2;
  f3->refineMesh("uniform", ave, ofname, false);
  meshBase *refined = meshBase::Create(ofname);
  // f3->unsetNewArrayNames();
  // f3->transfer(refined, "Consistent Interpolation", arrayIDs);
  auto f3refinedTransfer = NEM::DRV::TransferDriver::CreateTransferObject(
      f3, refined, "Consistent Interpolation");
  f3refinedTransfer->transferPointData(arrayIDs);
  delete f3;
  f3 = refined;
  computeRichardsonExtrapolation();
  f3->write(ofname);
}

computeOrderOfAccuracy()

std::vector< std::vector< double > > OrderOfAccuracy::computeOrderOfAccuracy

(

)

Returns

Order of accuracy for each component of each field based on errors between the coarse and finer mesh and the finer and finest mesh.

Definition at line 80 of file OrderOfAccuracy.C.

References diffF2F1, diffF3F2, orderOfAccuracy, r21, and r32.

Referenced by computeGCI_21(), computeGCI_32(), and computeRichardsonExtrapolation().

                                                                     {
  orderOfAccuracy.resize(diffF3F2.size());
  for (int i = 0; i < diffF3F2.size(); ++i) {
    orderOfAccuracy[i].resize(diffF3F2[i].size());
    for (int j = 0; j < diffF3F2[i].size(); ++j) {
      // Picard-type iteration to solve transcendental equation for p
      double q_p = 0;
      double f32_f21 = diffF3F2[i][j] / diffF2F1[i][j];
      int s = (f32_f21 > 0) - (f32_f21 < 0);
      double p = -1;
      double old_p = 1;
      for (int k = 0; k < 1000; ++k) {
        p = std::fabs(log(std::fabs(f32_f21)) + q_p) / log(r21);
        q_p = log((pow(r21, p) - s) / (pow(r32, p) - s));
        if (std::fabs(old_p - p) < 1e-16)
          break;
        else
          old_p = p;
      }
      orderOfAccuracy[i][j] = p;
    }
  }
  return orderOfAccuracy;
}

computeResolution()

std::vector< std::vector< double > > OrderOfAccuracy::computeResolution

(

double

gciStar

)

Given a vector field, select the maximum refinement ratio in the components to ensure the desired GCI is met across all components.

Returns

Necessary grid refinement ratio for each component of each field.

Definition at line 143 of file OrderOfAccuracy.C.

References computeGCI_32(), GCI_32, and orderOfAccuracy.

Referenced by computeMeshWithResolution().

                    {
  if (GCI_32.empty()) computeGCI_32();
  std::vector<std::vector<double>> res(GCI_32.size());
  for (int i = 0; i < GCI_32.size(); ++i) {
    res[i].resize(GCI_32[i].size());
    for (int j = 0; j < GCI_32[i].size(); ++j) {
      res[i][j] = pow(gciStar / GCI_32[i][j], 1. / orderOfAccuracy[i][j]);
    }
  }
  return res;
}

computeRichardsonExtrapolation()

void OrderOfAccuracy::computeRichardsonExtrapolation

(

)

Definition at line 199 of file OrderOfAccuracy.C.

References arrayIDs, computeOrderOfAccuracy(), NEM::DRV::TransferDriver::CreateTransferObject(), f1, f3, meshBase::getDataSet(), meshBase::getNewArrayNames(), meshBase::getNumberOfPoints(), id, NEM::MSH::New(), orderOfAccuracy, r21, and realDiffIDs.

Referenced by computeMeshWithResolution().

                                                     {
  if (orderOfAccuracy.empty()) computeOrderOfAccuracy();

  int numArr = arrayIDs.size();

  std::vector<vtkSmartPointer<vtkDoubleArray>> fineDatas(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> diffDatas(numArr);
  std::vector<vtkSmartPointer<vtkDoubleArray>> richardsonDatas(numArr);

  vtkSmartPointer<vtkPointData> finePD = f1->getDataSet()->GetPointData();

  std::vector<std::string> names(numArr);
  for (int id = 0; id < numArr; ++id) {
    diffDatas[id] =
        vtkDoubleArray::SafeDownCast(finePD->GetArray(realDiffIDs[id]));
    fineDatas[id] =
        vtkDoubleArray::SafeDownCast(finePD->GetArray(arrayIDs[id]));

    auto richardsonData = vtkSmartPointer<vtkDoubleArray>::New();
    richardsonData->SetNumberOfComponents(
        diffDatas[id]->GetNumberOfComponents());
    richardsonData->SetNumberOfTuples(f1->getNumberOfPoints());
    std::string name(finePD->GetArrayName(arrayIDs[id]));
    name += "_richExtrap";
    names[id] = name;
    richardsonData->SetName(&name[0u]);
    richardsonDatas[id] = richardsonData;
  }

  for (int i = 0; i < f1->getNumberOfPoints(); ++i) {
    for (int id = 0; id < numArr; ++id) {
      int numComponent = diffDatas[id]->GetNumberOfComponents();

      auto *fine_comps = new double[numComponent];
      fineDatas[id]->GetTuple(i, fine_comps);

      auto *diff_comps = new double[numComponent];
      diffDatas[id]->GetTuple(i, diff_comps);

      auto *val = new double[numComponent];
      for (int j = 0; j < numComponent; ++j) {
        double comp = fine_comps[j] +
                      diff_comps[j] / (pow(r21, orderOfAccuracy[id][j]) - 1);
        val[j] = comp;
      }
      richardsonDatas[id]->SetTuple(i, val);

      delete[] fine_comps;
      delete[] diff_comps;
      delete[] val;
    }
  }

  std::vector<int> richExtrapIDs(numArr);
  for (int id = 0; id < numArr; ++id) {
    finePD->AddArray(richardsonDatas[id]);
    finePD->GetArray(names[id].c_str(), richExtrapIDs[id]);
  }
  // f1->transfer(f3, "Consistent Interpolation", richExtrapIDs);
  auto f1f3Transfer = NEM::DRV::TransferDriver::CreateTransferObject(
      f1, f3, "Consistent Interpolation");
  f1f3Transfer->transferPointData(arrayIDs, f1->getNewArrayNames());
}

getDiffF2F1()

std::vector<std::vector<double> > OrderOfAccuracy::getDiffF2F1 ( ) const

inline

Definition at line 126 of file OrderOfAccuracy.H.

{ return diffF2F1; }

getOrderOfAccuracy()

std::vector<std::vector<double> > OrderOfAccuracy::getOrderOfAccuracy ( ) const

inline

Returns

Order of accuracy of each component of each field

Definition at line 103 of file OrderOfAccuracy.H.

References mesh.

                                                          {
    return orderOfAccuracy;
  }

getTargetGCI()

double OrderOfAccuracy::getTargetGCI ( ) const

inline

Definition at line 128 of file OrderOfAccuracy.H.

{ return targetGCI; }

Member Data Documentation

arrayIDs

const std::vector<int> OrderOfAccuracy::arrayIDs

private

Definition at line 134 of file OrderOfAccuracy.H.

Referenced by computeDiff(), computeMeshWithResolution(), computeRichardsonExtrapolation(), and OrderOfAccuracy().

diffF2F1

std::vector<std::vector<double> > OrderOfAccuracy::diffF2F1

private

Definition at line 148 of file OrderOfAccuracy.H.

Referenced by computeGCI_21(), computeOrderOfAccuracy(), and OrderOfAccuracy().

diffF3F2

std::vector<std::vector<double> > OrderOfAccuracy::diffF3F2

private

Definition at line 146 of file OrderOfAccuracy.H.

Referenced by computeGCI_32(), computeOrderOfAccuracy(), and OrderOfAccuracy().

diffIDs

std::vector<int> OrderOfAccuracy::diffIDs

private

Definition at line 136 of file OrderOfAccuracy.H.

Referenced by computeDiff(), and OrderOfAccuracy().

f1

meshBase * OrderOfAccuracy::f1

private

Definition at line 131 of file OrderOfAccuracy.H.

Referenced by computeGCI_21(), computeRichardsonExtrapolation(), and OrderOfAccuracy().

f2

meshBase * OrderOfAccuracy::f2

private

Definition at line 131 of file OrderOfAccuracy.H.

Referenced by computeGCI_32(), and OrderOfAccuracy().

f2ArrNames

std::vector<std::string> OrderOfAccuracy::f2ArrNames

private

Definition at line 141 of file OrderOfAccuracy.H.

Referenced by OrderOfAccuracy().

f3

meshBase* OrderOfAccuracy::f3

private

Definition at line 131 of file OrderOfAccuracy.H.

Referenced by computeMeshWithResolution(), computeRichardsonExtrapolation(), and OrderOfAccuracy().

f3ArrNames

std::vector<std::string> OrderOfAccuracy::f3ArrNames

private

Definition at line 141 of file OrderOfAccuracy.H.

Referenced by OrderOfAccuracy().

GCI_21

std::vector<std::vector<double> > OrderOfAccuracy::GCI_21

private

Definition at line 152 of file OrderOfAccuracy.H.

Referenced by checkAsymptoticRange(), and computeGCI_21().

GCI_32

std::vector<std::vector<double> > OrderOfAccuracy::GCI_32

private

Definition at line 150 of file OrderOfAccuracy.H.

Referenced by checkAsymptoticRange(), computeGCI_32(), and computeResolution().

orderOfAccuracy

std::vector<std::vector<double> > OrderOfAccuracy::orderOfAccuracy

private

Definition at line 154 of file OrderOfAccuracy.H.

Referenced by checkAsymptoticRange(), computeGCI_21(), computeGCI_32(), computeOrderOfAccuracy(), computeResolution(), and computeRichardsonExtrapolation().

r21

double OrderOfAccuracy::r21

private

Definition at line 144 of file OrderOfAccuracy.H.

Referenced by checkAsymptoticRange(), computeGCI_21(), computeOrderOfAccuracy(), computeRichardsonExtrapolation(), and OrderOfAccuracy().

r32

double OrderOfAccuracy::r32

private

Definition at line 144 of file OrderOfAccuracy.H.

Referenced by computeGCI_32(), computeOrderOfAccuracy(), and OrderOfAccuracy().

realDiffIDs

std::vector<int> OrderOfAccuracy::realDiffIDs

private

Definition at line 140 of file OrderOfAccuracy.H.

Referenced by computeDiff(), computeRichardsonExtrapolation(), and OrderOfAccuracy().

relEIDs

std::vector<int> OrderOfAccuracy::relEIDs

private

Definition at line 138 of file OrderOfAccuracy.H.

Referenced by computeDiff(), computeGCI_21(), computeGCI_32(), and OrderOfAccuracy().

targetGCI

double OrderOfAccuracy::targetGCI

private

Definition at line 156 of file OrderOfAccuracy.H.

---

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

• OrderOfAccuracy.H
• OrderOfAccuracy.C