void study_evacuation(Conjunct *C, which_way dir, int max_arity)
{
if (evac_debug > 0)
{
assert(max_arity >= 0);
if (max_arity > 0)
if (dir == in_to_out)
{
assert(max_arity <= C->relation()->n_inp());
if (max_arity <= C->relation()->n_out())
single_evacs[study(C, input_vars, output_vars,
C->relation()->n_inp(),
C->relation()->n_out(),
max_arity)]++;
}
else
{
assert(max_arity <= C->relation()->n_out());
if (max_arity <= C->relation()->n_inp())
single_evacs[study(C, output_vars, input_vars,
C->relation()->n_out(),
C->relation()->n_inp(),
max_arity)]++;
}
}
}
path path::extension() const {
if (empty()) return *this;
if (!_info.valid) study();
return _path.substr(_info.extension);
}
path path::parent_path() const {
/*
* special cases:
* /abc -> /
* /abc/ -> /abc
* all trailing /s are removed.
*
*/
if (empty()) return *this;
if (!_info.valid) study();
// "/" is a file of "/" with a parent of ""
if (_info.special == separator) return path();
// stem starts at 0, eg "abc"
if (!_info.stem) return path();
auto tmp = _path.substr(0, _info.stem - 1);
// remove trailing slashes, but return "/" if nothing BUT /s.
while (!tmp.empty() && tmp.back() == separator) tmp.pop_back();
if (tmp.empty()) return path_sep;
return path(tmp);
}
bool cmdline::Cmdline::parse(int argc, char* argv[], bool noMixed)
{
study();
for (int i = 0; i < argc; i++)
{
argv[i];
}
noMixed;
return true;
}
void InstancesAccessed::addStudy(std::string studyInstanceUid, std::vector<SOPClass> sopClasses)
{
EntityParticipantObject study(
EntityParticipantObject::Type::SystemObject, EntityParticipantObject::Role::Report,
generateParticipantObjectIDTypeCode(ParticipantObjectIDTypeCode::StudyInstanceUid),
std::move(studyInstanceUid));
study.setSOPClasses(std::move(sopClasses));
studies.emplace_back(std::move(study));
}
path path::filename() const {
if (empty()) return *this;
if (!_info.valid) study();
if (_info.special == separator) return path_sep;
if (_info.special == '.') return path_dot;
if (_info.stem == 0) return *this;
return _path.substr(_info.stem);
}
path path::stem() const {
// filename without the extension.
if (empty()) return *this;
if (!_info.valid) study();
if (_info.special == separator) return path_sep;
if (_info.special == '.') return path_dot;
return _path.substr(_info.stem, _info.extension - _info.stem);
}
bool path::has_parent_path() const
{
// if there is a /, it has a parent path.
// ... unless it's /.
if (empty()) return false;
if (!_info.valid) study();
if (_info.special == '/') return false;
return _path.find(separator) != _path.npos;
}
void study_evacuation(Conjunct *C1, Conjunct *C2, int max_arity)
{
if (evac_debug > 0)
{
assert(max_arity >= 0);
assert(max_arity <= C1->relation()->n_inp());
assert(C2->relation()->n_out() == C1->relation()->n_inp());
if (max_arity > 0)
if (max_arity <= C1->relation()->n_out() &&
max_arity <= C2->relation()->n_inp())
{
double_evacs[study(C1, input_vars, output_vars,
C1->relation()->n_inp(),
C1->relation()->n_out(),
max_arity)]
[study(C2, output_vars, input_vars,
C2->relation()->n_out(),
C2->relation()->n_inp(),
max_arity)]++;
}
else if (max_arity <= C1->relation()->n_out())
{
single_evacs[study(C1, input_vars, output_vars,
C1->relation()->n_inp(),
C1->relation()->n_out(),
max_arity)]++;
}
else if (max_arity <= C2->relation()->n_inp())
{
single_evacs[study(C2, output_vars, input_vars,
C2->relation()->n_out(),
C2->relation()->n_inp(),
max_arity)]++;
}
}
}
str
rxx::init (const char *pat, const char *opt)
{
extra = NULL;
nsubpat = 0;
ovector = NULL;
bool studyit = false;
int options = 0;
for (; *opt; opt++)
switch (*opt) {
case '^':
options |= PCRE_ANCHORED;
break;
case 'i':
options |= PCRE_CASELESS;
break;
case 's':
options |= PCRE_DOTALL;
break;
case 'm':
options |= PCRE_MULTILINE;
break;
case 'x':
options |= PCRE_EXTENDED;
break;
case 'U':
options |= PCRE_UNGREEDY;
break;
case 'X':
options |= PCRE_EXTRA;
break;
case 'S':
studyit = true;
break;
default:
return strbuf ("invalid regular expression option '%c'\n", *opt);
}
const char *errptr;
int erroffset;
re = pcre_compile (pat, options, &errptr, &erroffset, NULL);
if (!re) {
strbuf err;
err << "Invalid regular expression:\n"
<< " " << pat << "\n";
suio_fill (err.tosuio (), ' ', erroffset);
err << " ^\n"
<< errptr << ".\n";
return err;
}
if (studyit) {
str err = study ();
if (err)
return strbuf () << "Could not study regular expression: " << err;
}
int ns = pcre_info (re, NULL, NULL);
assert (ns >= 0);
ovecsize = (ns + 1) * 3;
return NULL;
}
bool HConvergenceStudyTests::testBestApproximationErrorComputation() {
bool success = true;
bool enrichVelocity = false; // true would be for the "compliant" norm, which isn't working well yet
int minLogElements = 0, maxLogElements = minLogElements;
int numCells1D = pow(2.0,minLogElements);
int H1Order = 1;
int pToAdd = 2;
double tol = 1e-16;
double Re = 40.0;
VarFactory varFactory = VGPStokesFormulation::vgpVarFactory();
VarPtr u1_vgp = varFactory.fieldVar(VGP_U1_S);
VarPtr u2_vgp = varFactory.fieldVar(VGP_U2_S);
VarPtr sigma11_vgp = varFactory.fieldVar(VGP_SIGMA11_S);
VarPtr sigma12_vgp = varFactory.fieldVar(VGP_SIGMA12_S);
VarPtr sigma21_vgp = varFactory.fieldVar(VGP_SIGMA21_S);
VarPtr sigma22_vgp = varFactory.fieldVar(VGP_SIGMA22_S);
VarPtr p_vgp = varFactory.fieldVar(VGP_P_S);
VGPStokesFormulation stokesForm(1/Re);
int numCellsFineMesh = 20; // for computing a zero-mean pressure
int H1OrderFineMesh = 5;
// define Kovasznay domain:
FieldContainer<double> quadPointsKovasznay(4,2);
// Domain from Evans Hughes for Navier-Stokes:
quadPointsKovasznay(0,0) = 0.0; // x1
quadPointsKovasznay(0,1) = -0.5; // y1
quadPointsKovasznay(1,0) = 1.0;
quadPointsKovasznay(1,1) = -0.5;
quadPointsKovasznay(2,0) = 1.0;
quadPointsKovasznay(2,1) = 0.5;
quadPointsKovasznay(3,0) = 0.0;
quadPointsKovasznay(3,1) = 0.5;
FunctionPtr zero = Function::zero();
bool dontEnhanceFluxes = false;
VGPNavierStokesProblem zeroProblem = VGPNavierStokesProblem(Re, quadPointsKovasznay,
numCellsFineMesh, numCellsFineMesh,
H1OrderFineMesh, pToAdd,
zero, zero, zero, enrichVelocity, dontEnhanceFluxes);
FunctionPtr u1_exact, u2_exact, p_exact;
NavierStokesFormulation::setKovasznay(Re, zeroProblem.mesh(), u1_exact, u2_exact, p_exact);
VGPNavierStokesProblem problem = VGPNavierStokesProblem(Re,quadPointsKovasznay,
numCells1D,numCells1D,
H1Order, pToAdd,
u1_exact, u2_exact, p_exact, enrichVelocity, dontEnhanceFluxes);
HConvergenceStudy study(problem.exactSolution(),
problem.mesh()->bilinearForm(),
problem.exactSolution()->rhs(),
problem.backgroundFlow()->bc(),
problem.bf()->graphNorm(),
minLogElements, maxLogElements,
H1Order, pToAdd, false, false, false);
study.setReportRelativeErrors(false); // we want absolute errors
Teuchos::RCP<Mesh> mesh = problem.mesh();
int cubatureDegreeEnrichment = 10;
int L2Order = H1Order - 1;
int meshCubatureDegree = L2Order + H1Order + pToAdd;
study.setCubatureDegreeForExact(cubatureDegreeEnrichment + meshCubatureDegree);
FunctionPtr f = u1_exact;
int trialID = u1_vgp->ID();
{
double fIntegral = f->integrate(mesh,cubatureDegreeEnrichment);
// cout << "testBestApproximationErrorComputation: integral of f on whole mesh = " << fIntegral << endl;
double l2ErrorOfAverage = (Function::constant(fIntegral) - f)->l2norm(mesh,cubatureDegreeEnrichment);
// cout << "testBestApproximationErrorComputation: l2 error of fIntegral: " << l2ErrorOfAverage << endl;
ElementTypePtr elemType = mesh->elementTypes()[0];
vector<GlobalIndexType> cellIDs = mesh->cellIDsOfTypeGlobal(elemType);
bool testVsTest = false;
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType, mesh, testVsTest, cubatureDegreeEnrichment) );
basisCache->setPhysicalCellNodes(mesh->physicalCellNodesGlobal(elemType), cellIDs, false); // false: no side cache
FieldContainer<double> projectionValues(cellIDs.size());
f->integrate(projectionValues, basisCache);
FieldContainer<double> cellMeasures = basisCache->getCellMeasures();
for (int i=0; i<projectionValues.size(); i++) {
projectionValues(i) /= cellMeasures(i);
}
// since we're not worried about the actual solution values at all, just use a single zero solution:
vector< SolutionPtr > solutions;
solutions.push_back( problem.backgroundFlow() );
study.setSolutions(solutions); // this will call computeError()
double approximationError = study.bestApproximationErrors()[trialID][0]; // 0: solution/mesh index
// for a single-cell mesh, approximation error should be the same as the L^2 error of the average
double diff = abs(approximationError - l2ErrorOfAverage);
if (diff > tol) {
cout << "testBestApproximationErrorComputation: diff " << diff << " exceeds tol " << tol << endl;
success = false;
} else {
// cout << "testBestApproximationErrorComputation: diff " << diff << " is below tol " << tol << endl;
}
}
return success;
}
