bool LinearTermTests::testLinearTermEvaluation()
{
bool success = true;
double eps = .1;
FunctionPtr one = Function::constant(1.0);
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define a couple LinearTerms
LinearTermPtr vVecLT = Teuchos::rcp(new LinearTerm);
LinearTermPtr tauVecLT = Teuchos::rcp(new LinearTerm);
vVecLT->addTerm(sqrt(eps)*v->grad());
tauVecLT->addTerm((1/sqrt(eps))*tau);
//////////////////// evaluate LinearTerms /////////////////
map<int,FunctionPtr> errRepMap;
errRepMap[v->ID()] = one;
errRepMap[tau->ID()] = one*e1+one*e2; // vector valued fxn (1,1)
FunctionPtr errTau = tauVecLT->evaluate(errRepMap,false);
FunctionPtr errV = vVecLT->evaluate(errRepMap,false);
try
{
bool xTauZero = errTau->x()->isZero();
bool yTauZero = errTau->y()->isZero();
bool xVZero = errV->dx()->isZero();
bool yVZero = errV->dy()->isZero();
}
catch (...)
{
cout << "testLinearTermEvaluation: Caught exception.\n";
success = false;
}
/*
FunctionPtr xErr = (errTau->x())*(errTau->x()) + (errV->dx())*(errV->dx());
FunctionPtr yErr = (errTau->y())*(errTau->y()) + (errV->dy())*(errV->dy());
double xErrVal = xErr->integrate(mesh,15,true);
*/
// if we don't crash, return success
return success;
}
bool LinearTermTests::testRieszInversionAsProjection()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 2;
int pToAdd = 2;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 2;
int horizontalCells = nCells, verticalCells = nCells;
// create a new mesh:
MeshPtr myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells, confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh));
vector<GlobalIndexType> cellIDs = myMesh->cellIDsOfTypeGlobal(elemType);
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(myMesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
LinearTermPtr integrand = Teuchos::rcp(new LinearTerm); // residual
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr testFxn1 = x;
FunctionPtr testFxn2 = y;
FunctionPtr fxnToProject = x * y + 1.0;
integrand->addTerm(fxnToProject * v);
IPPtr ip_L2 = Teuchos::rcp(new IP);
ip_L2->addTerm(v);
ip_L2->addTerm(tau);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, ip_L2, integrand));
riesz->computeRieszRep();
FunctionPtr rieszFxn = RieszRep::repFunction(v,riesz);
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numPts = basisCache->getPhysicalCubaturePoints().dimension(1);
FieldContainer<double> valProject( numCells, numPts );
FieldContainer<double> valExpected( numCells, numPts );
rieszFxn->values(valProject,basisCache);
fxnToProject->values(valExpected,basisCache);
// int rank = Teuchos::GlobalMPISession::getRank();
// if (rank==0) cout << "physicalCubaturePoints:\n" << basisCache->getPhysicalCubaturePoints();
double maxDiff;
double tol = 1e-12;
success = TestSuite::fcsAgree(valProject,valExpected,tol,maxDiff);
if (success==false)
{
cout << "Failed Riesz Inversion Projection test with maxDiff = " << maxDiff << endl;
serializeOutput("valExpected", valExpected);
serializeOutput("valProject", valProject);
serializeOutput("physicalPoints", basisCache->getPhysicalCubaturePoints());
}
return allSuccess(success);
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int rank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
int nCells = args.Input<int>("--nCells", "num cells",2);
int numSteps = args.Input<int>("--numSteps", "num NR steps",20);
int polyOrder = 0;
// define our manufactured solution or problem bilinear form:
bool useTriangles = false;
int pToAdd = 1;
args.Process();
int H1Order = polyOrder + 1;
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// new-style bilinear form definition
VarFactory varFactory;
VarPtr fn = varFactory.fluxVar("\\widehat{\\beta_n_u}");
VarPtr u = varFactory.fieldVar("u");
VarPtr v = varFactory.testVar("v",HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) ); // initialize bilinear form
////////////////////////////////////////////////////////////////////
// CREATE MESH
////////////////////////////////////////////////////////////////////
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells , bf, H1Order, H1Order+pToAdd);
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL); RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL); IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
SolutionPtr solnPerturbation = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
vector<double> e1(2),e2(2);
e1[0] = 1; e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// v:
bf->addTerm( -u, beta * v->grad());
bf->addTerm( fn, v);
////////////////////////////////////////////////////////////////////
// DEFINE RHS
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr u_prev_squared_div2 = 0.5 * u_prev * u_prev;
rhs->addTerm((e1 * u_prev_squared_div2 + e2 * u_prev) * v->grad());
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
FunctionPtr zero = Function::constant(0.0);
FunctionPtr u0 = Teuchos::rcp( new U0 );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
// FunctionPtr parity = Teuchos::rcp(new SideParityFunction);
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u0;
// functionMap[fn->ID()] = -(e1 * u0_squared_div_2 + e2 * u0) * n * parity;
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm( v );
ip->addTerm(v->grad());
// ip->addTerm( beta * v->grad() ); // omitting term to make IP non-dependent on u
////////////////////////////////////////////////////////////////////
// DEFINE DIRICHLET BC
////////////////////////////////////////////////////////////////////
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new TopBoundary);
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(outflowBoundary) );
Teuchos::RCP<BCEasy> inflowBC = Teuchos::rcp( new BCEasy );
inflowBC->addDirichlet(fn,inflowBoundary,
( e1 * u0_squared_div_2 + e2 * u0) * n );
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution); solution->setCubatureEnrichmentDegree(10);
////////////////////////////////////////////////////////////////////
// HESSIAN BIT + CHECKS ON GRADIENT + HESSIAN
////////////////////////////////////////////////////////////////////
VarFactory hessianVars = varFactory.getBubnovFactory(VarFactory::BUBNOV_TRIAL);
VarPtr du = hessianVars.test(u->ID());
// BFPtr hessianBF = Teuchos::rcp( new BF(hessianVars) ); // initialize bilinear form
FunctionPtr du_current = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr fnhat = Teuchos::rcp(new PreviousSolutionFunction(solution,fn));
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
residual->addTerm(fnhat*v,true);
residual->addTerm( - (e1 * (u_prev_squared_div2) + e2 * (u_prev)) * v->grad(),true);
LinearTermPtr Bdu = Teuchos::rcp(new LinearTerm);// residual
Bdu->addTerm( - du_current*(beta*v->grad()));
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
Teuchos::RCP<RieszRep> duRiesz = Teuchos::rcp(new RieszRep(mesh, ip, Bdu));
riesz->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,riesz));
e_v->writeValuesToMATLABFile(mesh, "e_v.m");
FunctionPtr posErrPart = Teuchos::rcp(new PositivePart(e_v->dx()));
// hessianBF->addTerm(e_v->dx()*u,du);
// hessianBF->addTerm(posErrPart*u,du);
// Teuchos::RCP<NullFilter> nullFilter = Teuchos::rcp(new NullFilter);
// Teuchos::RCP<HessianFilter> hessianFilter = Teuchos::rcp(new HessianFilter(hessianBF));
Teuchos::RCP< LineSearchStep > LS_Step = Teuchos::rcp(new LineSearchStep(riesz));
double NL_residual = 9e99;
for (int i = 0;i<numSteps;i++){
// write matrix to file and then resollve without hessian
/*
solution->setFilter(hessianFilter);
stringstream oss;
oss << "hessianMatrix" << i << ".dat";
solution->setWriteMatrixToFile(true,oss.str());
solution->solve(false);
solution->setFilter(nullFilter);
oss.str(""); // clear
oss << "stiffnessMatrix" << i << ".dat";
solution->setWriteMatrixToFile(false,oss.str());
*/
solution->solve(false); // do one solve to initialize things...
double stepLength = 1.0;
stepLength = LS_Step->stepSize(backgroundFlow,solution, NL_residual);
// solution->setWriteMatrixToFile(true,"stiffness.dat");
backgroundFlow->addSolution(solution,stepLength);
NL_residual = LS_Step->getNLResidual();
if (rank==0){
cout << "NL residual after adding = " << NL_residual << " with step size " << stepLength << endl;
}
double fd_gradient;
for (int dofIndex = 0;dofIndex<mesh->numGlobalDofs();dofIndex++){
TestingUtilities::initializeSolnCoeffs(solnPerturbation);
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,1.0,dofIndex);
fd_gradient = FiniteDifferenceUtilities::finiteDifferenceGradient(mesh, riesz, backgroundFlow, dofIndex);
// CHECK GRADIENT
LinearTermPtr b_u = bf->testFunctional(solnPerturbation);
map<int,FunctionPtr> NL_err_rep_map;
NL_err_rep_map[v->ID()] = Teuchos::rcp(new RepFunction(v,riesz));
FunctionPtr gradient = b_u->evaluate(NL_err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)); // use boundary part only if flux or trace
double grad;
if (TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)){
grad = gradient->integralOfJump(mesh,10);
}else{
grad = gradient->integrate(mesh,10);
}
double fdgrad = fd_gradient;
double diff = grad-fdgrad;
if (abs(diff)>1e-6 && i>0){
cout << "Found difference of " << diff << ", " << " with fd val = " << fdgrad << " and gradient = " << grad << " in dof " << dofIndex << ", isTraceDof = " << TestingUtilities::isFluxOrTraceDof(mesh,dofIndex) << endl;
}
}
}
VTKExporter exporter(solution, mesh, varFactory);
if (rank==0){
exporter.exportSolution("qopt");
cout << endl;
}
return 0;
}
bool LinearTermTests::testIntegrateMixedBasis()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u_hat = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE BILINEAR FORM/Mesh ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u_hat, v);
convectionBF->addTerm( u, v);
// build CONSTANT SINGLE ELEMENT MESH
int order = 0;
int H1Order = order+1;
int pToAdd = 1;
int nCells = 2; // along a side
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,convectionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = mesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, mesh));
vector<GlobalIndexType> cellIDs;
vector< ElementPtr > allElems = mesh->activeElements();
vector< ElementPtr >::iterator elemIt;
for (elemIt=allElems.begin(); elemIt!=allElems.end(); elemIt++)
{
cellIDs.push_back((*elemIt)->cellID());
}
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(mesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
int numTrialDofs = elemType->trialOrderPtr->totalDofs();
int numCells = mesh->numActiveElements();
double areaPerCell = 1.0 / numCells;
FieldContainer<double> integrals(numCells,numTrialDofs);
FieldContainer<double> expectedIntegrals(numCells,numTrialDofs);
double sidelengthOfCell = 1.0 / nCells;
DofOrderingPtr trialOrdering = elemType->trialOrderPtr;
int dofForField = trialOrdering->getDofIndex(u->ID(), 0);
vector<int> dofsForFlux;
const vector<int>* sidesForFlux = &trialOrdering->getSidesForVarID(beta_n_u_hat->ID());
for (vector<int>::const_iterator sideIt = sidesForFlux->begin(); sideIt != sidesForFlux->end(); sideIt++)
{
int sideIndex = *sideIt;
dofsForFlux.push_back(trialOrdering->getDofIndex(beta_n_u_hat->ID(), 0, sideIndex));
}
for (int cellIndex = 0; cellIndex < numCells; cellIndex++)
{
expectedIntegrals(cellIndex, dofForField) = areaPerCell;
for (vector<int>::iterator dofIt = dofsForFlux.begin(); dofIt != dofsForFlux.end(); dofIt++)
{
int fluxDofIndex = *dofIt;
expectedIntegrals(cellIndex, fluxDofIndex) = sidelengthOfCell;
}
}
// cout << "expectedIntegrals:\n" << expectedIntegrals;
// setup: with constant degrees of freedom, we expect that the integral of int_dK (flux) + int_K (field) will be ones for each degree of freedom, assuming the basis functions for these constants field/flux variables are just C = 1.0.
//
//On a unit square, int_K (constant) = 1.0, and int_dK (u_i) = 1, for i = 0,...,3.
LinearTermPtr lt = 1.0 * beta_n_u_hat;
LinearTermPtr field = 1.0 * u;
lt->addTerm(field,true);
lt->integrate(integrals, elemType->trialOrderPtr, basisCache);
double tol = 1e-12;
double maxDiff;
success = TestSuite::fcsAgree(integrals,expectedIntegrals,tol,maxDiff);
if (success==false)
{
cout << "Failed testIntegrateMixedBasis with maxDiff = " << maxDiff << endl;
}
return success;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int rank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
int nCells = args.Input<int>("--nCells", "num cells",2);
int numRefs = args.Input<int>("--numRefs","num adaptive refinements",0);
int numPreRefs = args.Input<int>("--numPreRefs","num preemptive adaptive refinements",0);
int order = args.Input<int>("--order","order of approximation",2);
double eps = args.Input<double>("--epsilon","diffusion parameter",1e-2);
double energyThreshold = args.Input<double>("-energyThreshold","energy thresh for adaptivity", .5);
double rampHeight = args.Input<double>("--rampHeight","ramp height at x = 2", 0.0);
bool useAnisotropy = args.Input<bool>("--useAnisotropy","aniso flag ", false);
FunctionPtr zero = Function::constant(0.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory.fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
// first order term with magnitude alpha
double alpha = 0.0;
confusionBF->addTerm(alpha * u, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
FunctionPtr C_h = Teuchos::rcp( new EpsilonScaling(eps) );
FunctionPtr invH = Teuchos::rcp(new InvHScaling);
FunctionPtr invSqrtH = Teuchos::rcp(new InvSqrtHScaling);
FunctionPtr sqrtH = Teuchos::rcp(new SqrtHScaling);
robIP->addTerm(v*alpha);
robIP->addTerm(invSqrtH*v);
// robIP->addTerm(v);
robIP->addTerm(sqrt(eps) * v->grad() );
robIP->addTerm(beta * v->grad() );
robIP->addTerm(tau->div() );
robIP->addTerm(C_h/sqrt(eps) * tau );
LinearTermPtr vVecLT = Teuchos::rcp(new LinearTerm);
LinearTermPtr tauVecLT = Teuchos::rcp(new LinearTerm);
vVecLT->addTerm(sqrt(eps)*v->grad());
tauVecLT->addTerm(C_h/sqrt(eps)*tau);
LinearTermPtr restLT = Teuchos::rcp(new LinearTerm);
restLT->addTerm(alpha*v);
restLT->addTerm(invSqrtH*v);
restLT = restLT + beta * v->grad();
restLT = restLT + tau->div();
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = zero;
// f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
// SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary );
// SpatialFilterPtr outflowBoundary = Teuchos::rcp( new OutflowSquareBoundary);
// bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, zero);
// bc->addDirichlet(uhat, outflowBoundary, zero);
SpatialFilterPtr rampInflow = Teuchos::rcp(new LeftInflow);
SpatialFilterPtr rampBoundary = MeshUtilities::rampBoundary(rampHeight);
SpatialFilterPtr freeStream = Teuchos::rcp(new FreeStreamBoundary);
SpatialFilterPtr outflowBoundary = Teuchos::rcp(new OutflowBoundary);
bc->addDirichlet(uhat, rampBoundary, one);
// bc->addDirichlet(uhat, outflowBoundary, one);
bc->addDirichlet(beta_n_u_minus_sigma_n, rampInflow, zero);
bc->addDirichlet(beta_n_u_minus_sigma_n, freeStream, zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
// Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildRampMesh(rampHeight,confusionBF, H1Order, H1Order+pToAdd);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
// solution->solve(false);
solution->condensedSolve();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution));
RieszRepPtr rieszResidual = Teuchos::rcp(new RieszRep(mesh, robIP, residual));
rieszResidual->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,rieszResidual));
FunctionPtr e_tau = Teuchos::rcp(new RepFunction(tau,rieszResidual));
map<int,FunctionPtr> errRepMap;
errRepMap[v->ID()] = e_v;
errRepMap[tau->ID()] = e_tau;
FunctionPtr errTau = tauVecLT->evaluate(errRepMap,false);
FunctionPtr errV = vVecLT->evaluate(errRepMap,false);
FunctionPtr errRest = restLT->evaluate(errRepMap,false);
FunctionPtr xErr = (errTau->x())*(errTau->x()) + (errV->dx())*(errV->dx());
FunctionPtr yErr = (errTau->y())*(errTau->y()) + (errV->dy())*(errV->dy());
FunctionPtr restErr = errRest*errRest;
RefinementStrategy refinementStrategy( solution, energyThreshold );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PRE REFINEMENTS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (rank==0)
{
cout << "Number of pre-refinements = " << numPreRefs << endl;
}
for (int i =0; i<=numPreRefs; i++)
{
vector<ElementPtr> elems = mesh->activeElements();
vector<ElementPtr>::iterator elemIt;
vector<int> wallCells;
for (elemIt=elems.begin(); elemIt != elems.end(); elemIt++)
{
int cellID = (*elemIt)->cellID();
int numSides = mesh->getElement(cellID)->numSides();
FieldContainer<double> vertices(numSides,2); //for quads
mesh->verticesForCell(vertices, cellID);
bool cellIDset = false;
for (int j = 0; j<numSides; j++)
{
if ((abs(vertices(j,0)-1.0)<1e-7) && (abs(vertices(j,1))<1e-7) && !cellIDset) // if at singularity, i.e. if a vertex is (1,0)
{
wallCells.push_back(cellID);
cellIDset = true;
}
}
}
if (i<numPreRefs)
{
refinementStrategy.refineCells(wallCells);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
VTKExporter exporter(solution, mesh, varFactory);
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
if (rank==0)
{
cout << "on ref index " << refIndex << endl;
}
rieszResidual->computeRieszRep(); // in preparation to get anisotropy
vector<int> cellIDs;
refinementStrategy.getCellsAboveErrorThreshhold(cellIDs);
map<int,double> energyError = solution->energyError();
map<int,double> xErrMap = xErr->cellIntegrals(cellIDs,mesh,5,true);
map<int,double> yErrMap = yErr->cellIntegrals(cellIDs,mesh,5,true);
map<int,double> restErrMap = restErr->cellIntegrals(cellIDs,mesh,5,true);
for (vector<ElementPtr>::iterator elemIt = mesh->activeElements().begin(); elemIt!=mesh->activeElements().end(); elemIt++)
{
int cellID = (*elemIt)->cellID();
double err = xErrMap[cellID]+ yErrMap[cellID] + restErrMap[cellID];
if (rank==0)
cout << "err thru LT = " << sqrt(err) << ", while energy err = " << energyError[cellID] << endl;
}
map<int,double> ratio,xErr,yErr;
vector<ElementPtr> elems = mesh->activeElements();
for (vector<ElementPtr>::iterator elemIt = elems.begin(); elemIt!=elems.end(); elemIt++)
{
int cellID = (*elemIt)->cellID();
ratio[cellID] = 0.0;
xErr[cellID] = 0.0;
yErr[cellID] = 0.0;
if (std::find(cellIDs.begin(),cellIDs.end(),cellID)!=cellIDs.end()) // if this cell is above energy thresh
{
ratio[cellID] = yErrMap[cellID]/xErrMap[cellID];
xErr[cellID] = xErrMap[cellID];
yErr[cellID] = yErrMap[cellID];
}
}
FunctionPtr ratioFxn = Teuchos::rcp(new EnergyErrorFunction(ratio));
FunctionPtr xErrFxn = Teuchos::rcp(new EnergyErrorFunction(xErr));
FunctionPtr yErrFxn = Teuchos::rcp(new EnergyErrorFunction(yErr));
std::ostringstream oss;
oss << refIndex;
exporter.exportFunction(ratioFxn, string("ratio")+oss.str());
exporter.exportFunction(xErrFxn, string("xErr")+oss.str());
exporter.exportFunction(yErrFxn, string("yErr")+oss.str());
if (useAnisotropy)
{
refinementStrategy.refine(rank==0,xErrMap,yErrMap); //anisotropic refinements
}
else
{
refinementStrategy.refine(rank==0); // no anisotropy
}
solution->condensedSolve();
}
// final solve on final mesh
solution->condensedSolve();
//////////////////// print to file ///////////////////////
FunctionPtr orderFxn = Teuchos::rcp(new MeshPolyOrderFunction(mesh));
std::ostringstream oss;
oss << nCells;
if (rank==0)
{
exporter.exportSolution(string("robustIP")+oss.str());
exporter.exportFunction(orderFxn, "meshOrder");
cout << endl;
}
return 0;
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int rank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
int nCells = args.Input<int>("--nCells", "num cells",2);
int numRefs = args.Input<int>("--numRefs","num adaptive refinements",0);
int numPreRefs = args.Input<int>("--numPreRefs","num preemptive adaptive refinements",0);
int order = args.Input<int>("--order","order of approximation",2);
double eps = args.Input<double>("--epsilon","diffusion parameter",1e-2);
double energyThreshold = args.Input<double>("-energyThreshold","energy thresh for adaptivity", .5);
double rampHeight = args.Input<double>("--rampHeight","ramp height at x = 2", 0.0);
double ipSwitch = args.Input<double>("--ipSwitch","point at which to switch to graph norm", 0.0); // default to 0 to remain on robust norm
bool useAnisotropy = args.Input<bool>("--useAnisotropy","aniso flag ", false);
int H1Order = order+1;
int pToAdd = args.Input<int>("--pToAdd","test space enrichment", 2);
FunctionPtr zero = Function::constant(0.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
vector<double> e1,e2;
e1.push_back(1.0);e1.push_back(0.0);
e2.push_back(0.0);e2.push_back(1.0);
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory.fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
// first order term with magnitude alpha
double alpha = 0.0;
// confusionBF->addTerm(alpha * u, v);
//////////////////// BUILD MESH ///////////////////////
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
MeshInfo meshInfo(mesh); // gets info like cell measure, etc
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
/*
// robust test norm
FunctionPtr C_h = Teuchos::rcp( new EpsilonScaling(eps) );
FunctionPtr invH = Teuchos::rcp(new InvHScaling);
FunctionPtr invSqrtH = Teuchos::rcp(new InvSqrtHScaling);
FunctionPtr sqrtH = Teuchos::rcp(new SqrtHScaling);
FunctionPtr hSwitch = Teuchos::rcp(new HSwitch(ipSwitch,mesh));
ip->addTerm(hSwitch*sqrt(eps) * v->grad() );
ip->addTerm(hSwitch*beta * v->grad() );
ip->addTerm(hSwitch*tau->div() );
// graph norm
ip->addTerm( (one-hSwitch)*((1.0/eps) * tau + v->grad()));
ip->addTerm( (one-hSwitch)*(beta * v->grad() - tau->div()));
// regularizing terms
ip->addTerm(C_h/sqrt(eps) * tau );
ip->addTerm(invSqrtH*v);
*/
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
FunctionPtr C_h = Teuchos::rcp( new EpsilonScaling(eps) );
FunctionPtr invH = Teuchos::rcp(new InvHScaling);
FunctionPtr invSqrtH = Teuchos::rcp(new InvSqrtHScaling);
FunctionPtr sqrtH = Teuchos::rcp(new SqrtHScaling);
FunctionPtr hSwitch = Teuchos::rcp(new HSwitch(ipSwitch,mesh));
robIP->addTerm(sqrt(eps) * v->grad() );
robIP->addTerm(beta * v->grad() );
robIP->addTerm(tau->div() );
// regularizing terms
robIP->addTerm(C_h/sqrt(eps) * tau );
robIP->addTerm(invSqrtH*v);
IPPtr graphIP = confusionBF->graphNorm();
graphIP->addTerm(invSqrtH*v);
// graphIP->addTerm(C_h/sqrt(eps) * tau );
IPPtr switchIP = Teuchos::rcp(new IPSwitcher(robIP,graphIP,ipSwitch)); // rob IP for h>ipSwitch mesh size, graph norm o/w
ip = switchIP;
LinearTermPtr vVecLT = Teuchos::rcp(new LinearTerm);
LinearTermPtr tauVecLT = Teuchos::rcp(new LinearTerm);
vVecLT->addTerm(sqrt(eps)*v->grad());
tauVecLT->addTerm(C_h/sqrt(eps)*tau);
LinearTermPtr restLT = Teuchos::rcp(new LinearTerm);
restLT->addTerm(alpha*v);
restLT->addTerm(invSqrtH*v);
restLT = restLT + beta * v->grad();
restLT = restLT + tau->div();
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = zero;
// f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
SpatialFilterPtr Inflow = Teuchos::rcp(new LeftInflow);
SpatialFilterPtr wallBoundary = Teuchos::rcp(new WallBoundary);//MeshUtilities::rampBoundary(rampHeight);
SpatialFilterPtr freeStream = Teuchos::rcp(new FreeStreamBoundary);
bc->addDirichlet(uhat, wallBoundary, one);
// bc->addDirichlet(uhat, wallBoundary, Teuchos::rcp(new WallSmoothBC(eps)));
bc->addDirichlet(beta_n_u_minus_sigma_n, Inflow, zero);
bc->addDirichlet(beta_n_u_minus_sigma_n, freeStream, zero);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
BCPtr nullBC = Teuchos::rcp((BC*)NULL); RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL); IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
mesh->registerSolution(backgroundFlow); // to trigger issue with p-refinements
map<int, Teuchos::RCP<Function> > functionMap; functionMap[u->ID()] = Function::constant(3.14);
backgroundFlow->projectOntoMesh(functionMap);
// lower p to p = 1 at SINGULARITY only
vector<int> ids;
/*
for (int i = 0;i<mesh->numActiveElements();i++){
bool cellIDset = false;
int cellID = mesh->activeElements()[i]->cellID();
int elemOrder = mesh->cellPolyOrder(cellID)-1;
FieldContainer<double> vv(4,2); mesh->verticesForCell(vv, cellID);
bool vertexOnWall = false; bool vertexAtSingularity = false;
for (int j = 0;j<4;j++){
if ((abs(vv(j,0)-.5) + abs(vv(j,1)))<1e-10){
vertexAtSingularity = true;
cellIDset = true;
}
}
if (!vertexAtSingularity && elemOrder<2 && !cellIDset ){
ids.push_back(cellID);
cout << "celliD = " << cellID << endl;
}
}
*/
ids.push_back(1);
ids.push_back(3);
mesh->pRefine(ids); // to put order = 1
return 0;
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution));
RieszRepPtr rieszResidual = Teuchos::rcp(new RieszRep(mesh, ip, residual));
rieszResidual->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,rieszResidual));
FunctionPtr e_tau = Teuchos::rcp(new RepFunction(tau,rieszResidual));
map<int,FunctionPtr> errRepMap;
errRepMap[v->ID()] = e_v;
errRepMap[tau->ID()] = e_tau;
FunctionPtr errTau = tauVecLT->evaluate(errRepMap,false);
FunctionPtr errV = vVecLT->evaluate(errRepMap,false);
FunctionPtr errRest = restLT->evaluate(errRepMap,false);
FunctionPtr xErr = (errTau->x())*(errTau->x()) + (errV->dx())*(errV->dx());
FunctionPtr yErr = (errTau->y())*(errTau->y()) + (errV->dy())*(errV->dy());
FunctionPtr restErr = errRest*errRest;
RefinementStrategy refinementStrategy( solution, energyThreshold );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PRE REFINEMENTS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (rank==0){
cout << "Number of pre-refinements = " << numPreRefs << endl;
}
for (int i =0;i<=numPreRefs;i++){
vector<ElementPtr> elems = mesh->activeElements();
vector<ElementPtr>::iterator elemIt;
vector<int> wallCells;
for (elemIt=elems.begin();elemIt != elems.end();elemIt++){
int cellID = (*elemIt)->cellID();
int numSides = mesh->getElement(cellID)->numSides();
FieldContainer<double> vertices(numSides,2); //for quads
mesh->verticesForCell(vertices, cellID);
bool cellIDset = false;
for (int j = 0;j<numSides;j++){
if ((abs(vertices(j,0)-.5)<1e-7) && (abs(vertices(j,1))<1e-7) && !cellIDset){ // if at singularity, i.e. if a vertex is (1,0)
wallCells.push_back(cellID);
cellIDset = true;
}
}
}
if (i<numPreRefs){
refinementStrategy.refineCells(wallCells);
}
}
double minSideLength = meshInfo.getMinCellSideLength() ;
double minCellMeasure = meshInfo.getMinCellMeasure() ;
if (rank==0){
cout << "after prerefs, sqrt min cell measure = " << sqrt(minCellMeasure) << ", min side length = " << minSideLength << endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
VTKExporter exporter(solution, mesh, varFactory);
for (int refIndex=0;refIndex<numRefs;refIndex++){
if (rank==0){
cout << "on ref index " << refIndex << endl;
}
rieszResidual->computeRieszRep(); // in preparation to get anisotropy
vector<int> cellIDs;
refinementStrategy.getCellsAboveErrorThreshhold(cellIDs);
map<int,double> energyError = solution->energyError();
map<int,double> xErrMap = xErr->cellIntegrals(cellIDs,mesh,5,true);
map<int,double> yErrMap = yErr->cellIntegrals(cellIDs,mesh,5,true);
map<int,double> restErrMap = restErr->cellIntegrals(cellIDs,mesh,5,true);
for (vector<ElementPtr>::iterator elemIt = mesh->activeElements().begin();elemIt!=mesh->activeElements().end();elemIt++){
int cellID = (*elemIt)->cellID();
double err = xErrMap[cellID]+ yErrMap[cellID] + restErrMap[cellID];
// if (rank==0)
// cout << "err thru LT = " << sqrt(err) << ", while energy err = " << energyError[cellID] << endl;
}
/*
map<int,double> ratio,xErr,yErr;
vector<ElementPtr> elems = mesh->activeElements();
for (vector<ElementPtr>::iterator elemIt = elems.begin();elemIt!=elems.end();elemIt++){
int cellID = (*elemIt)->cellID();
ratio[cellID] = 0.0;
xErr[cellID] = 0.0;
yErr[cellID] = 0.0;
if (std::find(cellIDs.begin(),cellIDs.end(),cellID)!=cellIDs.end()){ // if this cell is above energy thresh
ratio[cellID] = yErrMap[cellID]/xErrMap[cellID];
xErr[cellID] = xErrMap[cellID];
yErr[cellID] = yErrMap[cellID];
}
}
FunctionPtr ratioFxn = Teuchos::rcp(new EnergyErrorFunction(ratio));
FunctionPtr xErrFxn = Teuchos::rcp(new EnergyErrorFunction(xErr));
FunctionPtr yErrFxn = Teuchos::rcp(new EnergyErrorFunction(yErr));
exporter.exportFunction(ratioFxn, string("ratio")+oss.str());
exporter.exportFunction(xErrFxn, string("xErr")+oss.str());
exporter.exportFunction(yErrFxn, string("yErr")+oss.str());
*/
if (useAnisotropy){
refinementStrategy.refine(rank==0,xErrMap,yErrMap); //anisotropic refinements
}else{
refinementStrategy.refine(rank==0); // no anisotropy
}
// lower p to p = 1 at SINGULARITY only
vector<int> ids;
for (int i = 0;i<mesh->numActiveElements();i++){
int cellID = mesh->activeElements()[i]->cellID();
int elemOrder = mesh->cellPolyOrder(cellID)-1;
FieldContainer<double> vv(4,2); mesh->verticesForCell(vv, cellID);
bool vertexOnWall = false; bool vertexAtSingularity = false;
for (int j = 0;j<4;j++){
if ((abs(vv(j,0)-.5) + abs(vv(j,1)))<1e-10)
vertexAtSingularity = true;
}
if (!vertexAtSingularity && elemOrder<2){
ids.push_back(cellID);
}
}
mesh->pRefine(ids); // to put order = 1
/*
if (elemOrder>1){
if (vertexAtSingularity){
vector<int> ids;
ids.push_back(cellID);
mesh->pRefine(ids,1-(elemOrder-1)); // to put order = 1
// mesh->pRefine(ids); // to put order = 1
if (rank==0)
cout << "p unrefining elem with elemOrder = " << elemOrder << endl;
}
}else{
if (!vertexAtSingularity){
vector<int> ids;
ids.push_back(cellID);
mesh->pRefine(ids,2-elemOrder);
}
}
*/
double minSideLength = meshInfo.getMinCellSideLength() ;
if (rank==0)
cout << "minSideLength is " << minSideLength << endl;
solution->condensedSolve();
std::ostringstream oss;
oss << refIndex;
}
// final solve on final mesh
solution->setWriteMatrixToFile(true,"K.mat");
solution->condensedSolve();
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CHECK CONDITIONING
////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool checkConditioning = true;
if (checkConditioning){
double minSideLength = meshInfo.getMinCellSideLength() ;
StandardAssembler assembler(solution);
double maxCond = 0.0;
int maxCellID = 0;
for (int i = 0;i<mesh->numActiveElements();i++){
int cellID = mesh->getActiveElement(i)->cellID();
FieldContainer<double> ipMat = assembler.getIPMatrix(mesh->getElement(cellID));
double cond = SerialDenseWrapper::getMatrixConditionNumber(ipMat);
if (cond>maxCond){
maxCond = cond;
maxCellID = cellID;
}
}
if (rank==0){
cout << "cell ID " << maxCellID << " has minCellLength " << minSideLength << " and condition estimate " << maxCond << endl;
}
string ipMatName = string("ipMat.mat");
ElementPtr maxCondElem = mesh->getElement(maxCellID);
FieldContainer<double> ipMat = assembler.getIPMatrix(maxCondElem);
SerialDenseWrapper::writeMatrixToMatlabFile(ipMatName,ipMat);
}
//////////////////// print to file ///////////////////////
if (rank==0){
exporter.exportSolution(string("robustIP"));
cout << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
int rank=mpiSession.getRank();
int numProcs=mpiSession.getNProc();
#else
int rank = 0;
int numProcs = 1;
#endif
int polyOrder = 2;
// define our manufactured solution or problem bilinear form:
double epsilon = 1e-3;
bool useTriangles = false;
int pToAdd = 2;
int nCells = 2;
if ( argc > 1)
{
nCells = atoi(argv[1]);
if (rank==0)
{
cout << "numCells = " << nCells << endl;
}
}
int numSteps = 20;
if ( argc > 2)
{
numSteps = atoi(argv[2]);
if (rank==0)
{
cout << "num NR steps = " << numSteps << endl;
}
}
int useHessian = 0; // defaults to "not use"
if ( argc > 3)
{
useHessian = atoi(argv[3]);
if (rank==0)
{
cout << "useHessian = " << useHessian << endl;
}
}
int thresh = numSteps; // threshhold for when to apply linesearch/hessian
if ( argc > 4)
{
thresh = atoi(argv[4]);
if (rank==0)
{
cout << "thresh = " << thresh << endl;
}
}
int H1Order = polyOrder + 1;
double energyThreshold = 0.2; // for mesh refinements
double nonlinearStepSize = 0.5;
double nonlinearRelativeEnergyTolerance = 1e-8; // used to determine convergence of the nonlinear solution
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// new-style bilinear form definition
VarFactory varFactory;
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_hat = varFactory.fluxVar("\\widehat{\\beta_n u - \\sigma_n}");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
VarPtr tau = varFactory.testVar("\\tau",HDIV);
VarPtr v = varFactory.testVar("v",HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) ); // initialize bilinear form
////////////////////////////////////////////////////////////////////
// CREATE MESH
////////////////////////////////////////////////////////////////////
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells, bf, H1Order, H1Order+pToAdd);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC,
nullRHS, nullIP) );
vector<double> e1(2); // (1,0)
e1[0] = 1;
vector<double> e2(2); // (0,1)
e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// tau parts:
// 1/eps (sigma, tau)_K + (u, div tau)_K - (u_hat, tau_n)_dK
bf->addTerm(sigma1 / epsilon, tau->x());
bf->addTerm(sigma2 / epsilon, tau->y());
bf->addTerm(u, tau->div());
bf->addTerm( - uhat, tau->dot_normal() );
// v:
// (sigma, grad v)_K - (sigma_hat_n, v)_dK - (u, beta dot grad v) + (u_hat * n dot beta, v)_dK
bf->addTerm( sigma1, v->dx() );
bf->addTerm( sigma2, v->dy() );
bf->addTerm( -u, beta * v->grad());
bf->addTerm( beta_n_u_minus_sigma_hat, v);
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr u0 = Teuchos::rcp( new U0 );
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u0;
functionMap[sigma1->ID()] = zero;
functionMap[sigma2->ID()] = zero;
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
// function to scale the squared guy by epsilon/h
FunctionPtr epsilonOverHScaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm( epsilonOverHScaling * (1.0/sqrt(epsilon))* tau);
ip->addTerm( tau->div());
// ip->addTerm( epsilonOverHScaling * v );
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
ip->addTerm(v->grad());
// ip->addTerm( beta * v->grad() );
////////////////////////////////////////////////////////////////////
// DEFINE RHS
////////////////////////////////////////////////////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr u_prev_squared_div2 = 0.5 * u_prev * u_prev;
rhs->addTerm((e1 * u_prev_squared_div2 + e2 * u_prev) * v->grad() - u_prev * tau->div());
////////////////////////////////////////////////////////////////////
// DEFINE DIRICHLET BC
////////////////////////////////////////////////////////////////////
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new TopBoundary);
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(outflowBoundary) );
BCPtr inflowBC = BC::bc();
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
inflowBC->addDirichlet(beta_n_u_minus_sigma_hat,inflowBoundary,
( e1 * u0_squared_div_2 + e2 * u0) * n );
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution);
////////////////////////////////////////////////////////////////////
// WARNING: UNFINISHED HESSIAN BIT
////////////////////////////////////////////////////////////////////
VarFactory hessianVars = varFactory.getBubnovFactory(VarFactory::BUBNOV_TRIAL);
VarPtr du = hessianVars.test(u->ID());
BFPtr hessianBF = Teuchos::rcp( new BF(hessianVars) ); // initialize bilinear form
// FunctionPtr e_v = Function::constant(1.0); // dummy error rep function for now - should do nothing
FunctionPtr u_current = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr sig1_prev = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma1) );
FunctionPtr sig2_prev = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma2) );
FunctionPtr sig_prev = (e1*sig1_prev + e2*sig2_prev);
FunctionPtr fnhat = Teuchos::rcp(new PreviousSolutionFunction(solution,beta_n_u_minus_sigma_hat));
FunctionPtr uhat_prev = Teuchos::rcp(new PreviousSolutionFunction(solution,uhat));
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
residual->addTerm(fnhat*v - (e1 * (u_prev_squared_div2 - sig1_prev) + e2 * (u_prev - sig2_prev)) * v->grad());
residual->addTerm((1/epsilon)*sig_prev * tau + u_prev * tau->div() - uhat_prev*tau->dot_normal());
LinearTermPtr Bdu = Teuchos::rcp(new LinearTerm);// residual
Bdu->addTerm( u_current*tau->div() - u_current*(beta*v->grad()));
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
Teuchos::RCP<RieszRep> duRiesz = Teuchos::rcp(new RieszRep(mesh, ip, Bdu));
riesz->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,riesz));
e_v->writeValuesToMATLABFile(mesh, "e_v.m");
FunctionPtr posErrPart = Teuchos::rcp(new PositivePart(e_v->dx()));
hessianBF->addTerm(e_v->dx()*u,du);
// hessianBF->addTerm(posErrPart*u,du);
Teuchos::RCP<HessianFilter> hessianFilter = Teuchos::rcp(new HessianFilter(hessianBF));
if (useHessian)
{
solution->setWriteMatrixToFile(true,"hessianStiffness.dat");
}
else
{
solution->setWriteMatrixToFile(true,"stiffness.dat");
}
Teuchos::RCP< LineSearchStep > LS_Step = Teuchos::rcp(new LineSearchStep(riesz));
ofstream out;
out.open("Burgers.txt");
double NL_residual = 9e99;
for (int i = 0; i<numSteps; i++)
{
solution->solve(false); // do one solve to initialize things...
double stepLength = 1.0;
stepLength = LS_Step->stepSize(backgroundFlow,solution, NL_residual);
if (useHessian)
{
solution->setFilter(hessianFilter);
}
backgroundFlow->addSolution(solution,stepLength);
NL_residual = LS_Step->getNLResidual();
if (rank==0)
{
cout << "NL residual after adding = " << NL_residual << " with step size " << stepLength << endl;
out << NL_residual << endl; // saves initial NL error
}
}
out.close();
////////////////////////////////////////////////////////////////////
// DEFINE REFINEMENT STRATEGY
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RefinementStrategy> refinementStrategy;
refinementStrategy = Teuchos::rcp(new RefinementStrategy(solution,energyThreshold));
int numRefs = 0;
Teuchos::RCP<NonlinearStepSize> stepSize = Teuchos::rcp(new NonlinearStepSize(nonlinearStepSize));
Teuchos::RCP<NonlinearSolveStrategy> solveStrategy;
solveStrategy = Teuchos::rcp( new NonlinearSolveStrategy(backgroundFlow, solution, stepSize,
nonlinearRelativeEnergyTolerance));
////////////////////////////////////////////////////////////////////
// SOLVE
////////////////////////////////////////////////////////////////////
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
solveStrategy->solve(rank==0); // print to console on rank 0
refinementStrategy->refine(rank==0); // print to console on rank 0
}
// solveStrategy->solve(rank==0);
if (rank==0)
{
backgroundFlow->writeToVTK("Burgers.vtu",min(H1Order+1,4));
solution->writeFluxesToFile(uhat->ID(), "burgers.dat");
cout << "wrote solution files" << endl;
}
return 0;
}
// tests to make sure the energy error calculated thru direct integration works for vector valued test functions too
bool ScratchPadTests::testLTResidual()
{
double tol = 1e-11;
int rank = Teuchos::GlobalMPISession::getRank();
bool success = true;
int nCells = 2;
double eps = .1;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// choose the mesh-independent norm even though it may have boundary layers
ip->addTerm(v->grad());
ip->addTerm(v);
ip->addTerm(tau);
ip->addTerm(tau->div());
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one; // if this is set to zero instead, we pass the test (a clue?)
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr squareBoundary = Teuchos::rcp( new SquareBoundary );
bc->addDirichlet(uhat, squareBoundary, one);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
double energyError = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution),true);
// FunctionPtr uh = Function::solution(uhat,solution);
// FunctionPtr fn = Function::solution(beta_n_u_minus_sigma_n,solution);
// FunctionPtr uF = Function::solution(u,solution);
// FunctionPtr sigma = e1*Function::solution(sigma1,solution)+e2*Function::solution(sigma2,solution);
// residual->addTerm(- (fn*v - uh*tau->dot_normal()));
// residual->addTerm(- (uF*(tau->div() - beta*v->grad()) + sigma*((1/eps)*tau + v->grad())));
// residual->addTerm(-(fn*v - uF*beta*v->grad() + sigma*v->grad())); // just v portion
// residual->addTerm(uh*tau->dot_normal() - uF*tau->div() - sigma*((1/eps)*tau)); // just tau portion
Teuchos::RCP<RieszRep> rieszResidual = Teuchos::rcp(new RieszRep(mesh, ip, residual));
rieszResidual->computeRieszRep();
double energyErrorLT = rieszResidual->getNorm();
int cubEnrich = 0;
bool testVsTest = true;
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszResidual);
// experiment by Nate: manually specify the error (this appears to produce identical results, as it should)
// FunctionPtr err = e_v * e_v + e_tau * e_tau + e_v->grad() * e_v->grad() + e_tau->div() * e_tau->div();
map<int,FunctionPtr> errFxns;
errFxns[v->ID()] = e_v;
errFxns[tau->ID()] = e_tau;
LinearTermPtr ipAtErrFxns = ip->evaluate(errFxns);
FunctionPtr err = ip->evaluate(errFxns)->evaluate(errFxns);
double energyErrorIntegrated = sqrt(err->integrate(mesh,cubEnrich,testVsTest));
// check that energy error computed thru Solution and through rieszRep are the same
bool success1 = abs(energyError-energyErrorLT)<tol;
// checks that matrix-computed and integrated errors are the same
bool success2 = abs(energyErrorLT-energyErrorIntegrated)<tol;
success = success1==true && success2==true;
if (!success)
{
if (rank==0)
cout << "Failed testLTResidual; energy error = " << energyError << ", while linearTerm error is computed to be " << energyErrorLT << ", and when computing through integration of the Riesz rep function, error = " << energyErrorIntegrated << endl;
}
// VTKExporter exporter(solution, mesh, varFactory);
// exporter.exportSolution("testLTRes");
// cout << endl;
return success;
}
bool ScratchPadTests::testGalerkinOrthogonality()
{
double tol = 1e-11;
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
ip->addTerm(v);
ip->addTerm(beta*v->grad());
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
//////////////////// BUILD MESH ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
FunctionPtr n = Function::normal();
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u, v);
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(4, convectionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE ///////////////////////
RHSPtr rhs = RHS::rhs();
BCPtr bc = BC::bc();
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(inflowBoundary) );
FunctionPtr uIn;
uIn = Teuchos::rcp(new Uinflow); // uses a discontinuous piecewise-constant basis function on left and bottom sides of square
bc->addDirichlet(beta_n_u, inflowBoundary, beta*n*uIn);
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
FunctionPtr uFxn = Function::solution(u, solution);
FunctionPtr fnhatFxn = Function::solution(beta_n_u,solution);
// make residual for riesz representation function
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
FunctionPtr parity = Function::sideParity();
residual->addTerm(-fnhatFxn*v + (beta*uFxn)*v->grad());
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
riesz->computeRieszRep();
map<int,FunctionPtr> err_rep_map;
err_rep_map[v->ID()] = RieszRep::repFunction(v,riesz);
//////////////////// GET BOUNDARY CONDITION DATA ///////////////////////
FieldContainer<GlobalIndexType> bcGlobalIndices;
FieldContainer<double> bcGlobalValues;
mesh->boundary().bcsToImpose(bcGlobalIndices,bcGlobalValues,*(solution->bc()), NULL);
set<int> bcInds;
for (int i=0; i<bcGlobalIndices.dimension(0); i++)
{
bcInds.insert(bcGlobalIndices(i));
}
//////////////////// CHECK GALERKIN ORTHOGONALITY ///////////////////////
BCPtr nullBC;
RHSPtr nullRHS;
IPPtr nullIP;
SolutionPtr solnPerturbation = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
map< int, vector<DofInfo> > infoMap = constructGlobalDofToLocalDofInfoMap(mesh);
for (map< int, vector<DofInfo> >::iterator mapIt = infoMap.begin();
mapIt != infoMap.end(); mapIt++)
{
int dofIndex = mapIt->first;
vector< DofInfo > dofInfoVector = mapIt->second; // all the local dofs that map to dofIndex
// create perturbation in direction du
solnPerturbation->clear(); // clear all solns
// set each corresponding local dof to 1.0
for (vector< DofInfo >::iterator dofInfoIt = dofInfoVector.begin();
dofInfoIt != dofInfoVector.end(); dofInfoIt++)
{
DofInfo info = *dofInfoIt;
FieldContainer<double> solnCoeffs(info.basisCardinality);
solnCoeffs(info.basisOrdinal) = 1.0;
solnPerturbation->setSolnCoeffsForCellID(solnCoeffs, info.cellID, info.trialID, info.sideIndex);
}
// solnPerturbation->setSolnCoeffForGlobalDofIndex(1.0,dofIndex);
LinearTermPtr b_du = convectionBF->testFunctional(solnPerturbation);
FunctionPtr gradient = b_du->evaluate(err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)); // use boundary part only if flux
double grad = gradient->integrate(mesh,10);
if (!TestingUtilities::isFluxOrTraceDof(mesh,dofIndex) && abs(grad)>tol) // if we're not single-precision zero FOR FIELDS
{
// int cellID = mesh->getGlobalToLocalMap()[dofIndex].first;
cout << "Failed testGalerkinOrthogonality() for fields with diff " << abs(grad) << " at dof " << dofIndex << "; info:" << endl;
cout << dofInfoString(infoMap[dofIndex]);
success = false;
}
}
FieldContainer<double> errorJumps(mesh->numGlobalDofs()); //initialized to zero
// just test fluxes ON INTERNAL SKELETON here
set<GlobalIndexType> activeCellIDs = mesh->getActiveCellIDsGlobal();
for (GlobalIndexType activeCellID : activeCellIDs)
{
ElementPtr elem = mesh->getElement(activeCellID);
for (int sideIndex = 0; sideIndex < 4; sideIndex++)
{
ElementTypePtr elemType = elem->elementType();
vector<int> localDofIndices = elemType->trialOrderPtr->getDofIndices(beta_n_u->ID(), sideIndex);
for (int i = 0; i<localDofIndices.size(); i++)
{
int globalDofIndex = mesh->globalDofIndex(elem->cellID(), localDofIndices[i]);
vector< DofInfo > dofInfoVector = infoMap[globalDofIndex];
solnPerturbation->clear();
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,1.0,globalDofIndex);
// also add in BCs
for (int i = 0; i<bcGlobalIndices.dimension(0); i++)
{
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,bcGlobalValues(i),bcGlobalIndices(i));
}
LinearTermPtr b_du = convectionBF->testFunctional(solnPerturbation);
FunctionPtr gradient = b_du->evaluate(err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,globalDofIndex)); // use boundary part only if flux
double jump = gradient->integrate(mesh,10);
errorJumps(globalDofIndex) += jump;
}
}
}
for (int i = 0; i<mesh->numGlobalDofs(); i++)
{
if (abs(errorJumps(i))>tol)
{
cout << "Failing Galerkin orthogonality test for fluxes with diff " << errorJumps(i) << " at dof " << i << endl;
cout << dofInfoString(infoMap[i]);
success = false;
}
}
return success;
}
// tests to make sure that the rieszNorm computed via matrices is the same as the one computed thru direct integration
bool ScratchPadTests::testRieszIntegration()
{
double tol = 1e-11;
bool success = true;
int nCells = 2;
double eps = .25;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// just H1 projection
ip->addTerm(v->grad());
ip->addTerm(v);
ip->addTerm(tau);
ip->addTerm(tau->div());
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr squareBoundary = Teuchos::rcp( new SquareBoundary );
bc->addDirichlet(uhat, squareBoundary, zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
LinearTermPtr lt = Teuchos::rcp(new LinearTerm);
FunctionPtr fxn = Function::xn(1); // fxn = x
lt->addTerm(fxn*v + fxn->grad()*v->grad());
lt->addTerm(fxn*tau->x() + fxn*tau->y() + (fxn->dx() + fxn->dy())*tau->div());
Teuchos::RCP<RieszRep> rieszLT = Teuchos::rcp(new RieszRep(mesh, ip, lt));
rieszLT->computeRieszRep();
double rieszNorm = rieszLT->getNorm();
FunctionPtr e_v = RieszRep::repFunction(v,rieszLT);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszLT);
map<int,FunctionPtr> repFxns;
repFxns[v->ID()] = e_v;
repFxns[tau->ID()] = e_tau;
double integratedNorm = sqrt((lt->evaluate(repFxns,false))->integrate(mesh,5,true));
success = abs(rieszNorm-integratedNorm)<tol;
if (success==false)
{
cout << "Failed testRieszIntegration; riesz norm is computed to be = " << rieszNorm << ", while using integration it's computed to be " << integratedNorm << endl;
return success;
}
return success;
}
// tests whether a mixed type LT
bool ScratchPadTests::testIntegrateDiscontinuousFunction()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
ip->addTerm(v);
ip->addTerm(beta*v->grad());
// for projections
IPPtr ipL2 = Teuchos::rcp(new IP);
ipL2->addTerm(v);
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
//////////////////// BUILD MESH ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u, v);
// define nodes for mesh
int order = 1;
int H1Order = order+1;
int pToAdd = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(2, 1, convectionBF, H1Order, H1Order+pToAdd);
//////////////////// integrate discontinuous function - cellIDFunction ///////////////////////
// FunctionPtr cellIDFxn = Teuchos::rcp(new CellIDFunction); // should be 0 on cellID 0, 1 on cellID 1
set<int> cellIDs;
cellIDs.insert(1); // 0 on cell 0, 1 on cell 1
FunctionPtr indicator = Teuchos::rcp(new IndicatorFunction(cellIDs)); // should be 0 on cellID 0, 1 on cellID 1
double jumpWeight = 13.3; // some random number
FunctionPtr edgeRestrictionFxn = Teuchos::rcp(new EdgeFunction);
FunctionPtr X = Function::xn(1);
LinearTermPtr integrandLT = Function::constant(1.0)*v + Function::constant(jumpWeight)*X*edgeRestrictionFxn*v;
// make riesz representation function to more closely emulate the error rep
LinearTermPtr indicatorLT = Teuchos::rcp(new LinearTerm);// residual
indicatorLT->addTerm(indicator*v);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ipL2, indicatorLT));
riesz->computeRieszRep();
map<int,FunctionPtr> vmap;
vmap[v->ID()] = RieszRep::repFunction(v,riesz); // SHOULD BE L2 projection = same thing!!!
FunctionPtr volumeIntegrand = integrandLT->evaluate(vmap,false);
FunctionPtr edgeRestrictedIntegrand = integrandLT->evaluate(vmap,true);
double edgeRestrictedValue = volumeIntegrand->integrate(mesh,10) + edgeRestrictedIntegrand->integrate(mesh,10);
double expectedValue = .5 + .5*jumpWeight;
double diff = abs(expectedValue-edgeRestrictedValue);
if (abs(diff)>1e-11)
{
success = false;
cout << "Failed testIntegrateDiscontinuousFunction() with expectedValue = " << expectedValue << " and actual value = " << edgeRestrictedValue << endl;
}
return success;
}
// tests whether a mixed type LT
bool ScratchPadTests::testLinearTermEvaluationConsistency()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
ip->addTerm(v);
ip->addTerm(beta*v->grad());
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
//////////////////// BUILD MESH ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u, v);
// define nodes for mesh
int order = 1;
int H1Order = order+1;
int pToAdd = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(1, convectionBF, H1Order, H1Order+pToAdd);
//////////////////// get fake residual ///////////////////////
LinearTermPtr lt = Teuchos::rcp(new LinearTerm);
FunctionPtr edgeFxn = Teuchos::rcp(new EdgeFunction);
FunctionPtr Xsq = Function::xn(2);
FunctionPtr Ysq = Function::yn(2);
FunctionPtr XYsq = Xsq*Ysq;
lt->addTerm(edgeFxn*v + (beta*XYsq)*v->grad());
Teuchos::RCP<RieszRep> ltRiesz = Teuchos::rcp(new RieszRep(mesh, ip, lt));
ltRiesz->computeRieszRep();
FunctionPtr repFxn = RieszRep::repFunction(v,ltRiesz);
map<int,FunctionPtr> rep_map;
rep_map[v->ID()] = repFxn;
FunctionPtr edgeLt = lt->evaluate(rep_map, true) ;
FunctionPtr elemLt = lt->evaluate(rep_map, false);
double edgeVal = edgeLt->integrate(mesh,10);
double elemVal = elemLt->integrate(mesh,10);
LinearTermPtr edgeOnlyLt = Teuchos::rcp(new LinearTerm);// residual
edgeOnlyLt->addTerm(edgeFxn*v);
FunctionPtr edgeOnly = edgeOnlyLt->evaluate(rep_map,true);
double edgeOnlyVal = edgeOnly->integrate(mesh,10);
double diff = edgeOnlyVal-edgeVal;
if (abs(diff)>1e-11)
{
success = false;
cout << "Failed testLinearTermEvaluationConsistency() with diff = " << diff << endl;
}
return success;
}
bool ScratchPadTests::testResidualMemoryError()
{
int rank = Teuchos::GlobalMPISession::getRank();
double tol = 1e-11;
bool success = true;
int nCells = 2;
double eps = 1e-2;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
robIP->addTerm(tau);
robIP->addTerm(tau->div());
robIP->addTerm(v->grad());
robIP->addTerm(v);
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr zero = Function::constant(0.0);
FunctionPtr one = Function::constant(1.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = zero;
// FunctionPtr f = one;
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new LRInflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new LROutflowSquareBoundary);
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta*n*one);
bc->addDirichlet(uhat, outflowBoundary, zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
// mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
solution->solve(false);
mesh->registerSolution(solution);
double energyErr1 = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution));
RieszRepPtr rieszResidual = Teuchos::rcp(new RieszRep(mesh, robIP, residual));
rieszResidual->computeRieszRep();
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
FunctionPtr e_tau = RieszRep::repFunction(tau,rieszResidual);
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
refinementStrategy.refine();
solution->solve(false);
double energyErr2 = solution->energyErrorTotal();
// if energy error rises
if (energyErr1 < energyErr2)
{
if (rank==0)
cout << "energy error increased from " << energyErr1 << " to " << energyErr2 << " after refinement.\n";
success = false;
}
return success;
}
bool LinearTermTests::testMixedTermConsistency()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 1;
int pToAdd = 1;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 1;
int horizontalCells = nCells, verticalCells = nCells;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
// DofOrderingPtr testOrder = elemType->testOrderPtr;
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh, true));
LinearTermPtr integrandIBP = Teuchos::rcp(new LinearTerm);// residual
vector<double> e1(2); // (1,0)
vector<double> e2(2); // (0,1)
e1[0] = 1;
e2[1] = 1;
FunctionPtr n = Function::normal();
FunctionPtr X = Function::xn(1);
FunctionPtr Y = Function::yn(1);
FunctionPtr testFxn1 = X;
FunctionPtr testFxn2 = Y;
FunctionPtr divTestFxn = testFxn1->dx() + testFxn2->dy();
FunctionPtr vectorTest = testFxn1*e1 + testFxn2*e2;
integrandIBP->addTerm(vectorTest*n*v + -vectorTest*v->grad()); // boundary term
// define dummy IP to initialize riesz rep class, but just integrate RHS
IPPtr dummyIP = Teuchos::rcp(new IP);
dummyIP->addTerm(v);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, dummyIP, integrandIBP));
map<GlobalIndexType,FieldContainer<double> > rieszRHS = riesz->integrateFunctional();
set<GlobalIndexType> cellIDs = myMesh->cellIDsInPartition();
for (set<GlobalIndexType>::iterator cellIDIt=cellIDs.begin(); cellIDIt !=cellIDs.end(); cellIDIt++)
{
GlobalIndexType cellID = *cellIDIt;
ElementTypePtr elemTypePtr = myMesh->getElementType(cellID);
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
int numTestDofs = testOrderingPtr->totalDofs();
BasisCachePtr basisCache = BasisCache::basisCacheForCell(myMesh, cellID, true);
FieldContainer<double> rhsIBPValues(1,numTestDofs);
integrandIBP->integrate(rhsIBPValues, testOrderingPtr, basisCache);
FieldContainer<double> rieszValues(1,numTestDofs);
(riesz->getFunctional())->integrate(rieszValues, testOrderingPtr, basisCache);
double maxDiff;
double tol = 1e-13;
FieldContainer<double> rhsIBPVals(numTestDofs);
for (int i = 0; i< numTestDofs; i++)
{
rhsIBPVals(i) = rhsIBPValues(0,i);
// cout << "riesz rhs values = " << rieszRHS[cellID](i) << ", rhsIBPValues = " << rhsIBPVals(i) << ", riesz returned values = " << rieszValues(0,i) << endl;
}
bool fcsAgree = TestSuite::fcsAgree(rieszRHS[cellID],rhsIBPVals,tol,maxDiff);
if (!fcsAgree)
{
success=false;
cout << "Failed mixed term consistency test with maxDiff = " << maxDiff << " on cellID " << cellID<< endl;
}
}
return allSuccess(success);
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
bool steady = args.Input<bool>("--steady", "run steady rather than transient");
// Optional arguments (have defaults)
double dt = args.Input("--dt", "time step", 0.25);
int numTimeSteps = args.Input("--nt", "number of time steps", 20);
halfWidth = args.Input("--halfWidth", "half width of inlet profile", 1.0);
args.Process();
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u_hat = varFactory.fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory.fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = 0.0; // x1
meshBoundary(0,1) = -2.0; // y1
meshBoundary(1,0) = 4.0;
meshBoundary(1,1) = -2.0;
meshBoundary(2,0) = 4.0;
meshBoundary(2,1) = 2.0;
meshBoundary(3,0) = 0.0;
meshBoundary(3,1) = 2.0;
int horizontalCells = 8, verticalCells = 8;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+pToAdd);
////////////////////////////////////////////////////////////////////
// INITIALIZE FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr prevTimeFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
SolutionPtr flowResidual = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
FunctionPtr u_prev_time = Teuchos::rcp( new PreviousSolutionFunction(prevTimeFlow, u) );
//////////////////// DEFINE BILINEAR FORM ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr invDt = Teuchos::rcp(new ScalarParamFunction(1.0/dt));
// v terms:
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_hat, v);
if (!steady)
{
bf->addTerm( u, invDt*v );
rhs->addTerm( u_prev_time * invDt * v );
}
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
// ip->addTerm(v);
// ip->addTerm(beta*v->grad());
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
FunctionPtr u1 = Teuchos::rcp( new InletBC );
bc->addDirichlet(beta_n_u_hat, lBoundary, -u1);
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(prevTimeFlow);
mesh->registerSolution(flowResidual);
// ==================== SET INITIAL GUESS ==========================
double u_free = 0.0;
map<int, Teuchos::RCP<Function> > functionMap;
// functionMap[u->ID()] = Teuchos::rcp( new ConInletBC
functionMap[u->ID()] = Teuchos::rcp( new InletBC );
prevTimeFlow->projectOntoMesh(functionMap);
//////////////////// SOLVE & REFINE ///////////////////////
if (enforceLocalConservation)
{
if (steady)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_hat == zero);
}
else
{
// FunctionPtr parity = Teuchos::rcp<Function>( new SideParityFunction );
// LinearTermPtr conservedQuantity = Teuchos::rcp<LinearTerm>( new LinearTerm(parity, beta_n_u_minus_sigma_n) );
LinearTermPtr conservedQuantity = Teuchos::rcp<LinearTerm>( new LinearTerm(1.0, beta_n_u_hat) );
LinearTermPtr sourcePart = Teuchos::rcp<LinearTerm>( new LinearTerm(invDt, u) );
conservedQuantity->addTerm(sourcePart, true);
solution->lagrangeConstraints()->addConstraint(conservedQuantity == u_prev_time * invDt);
}
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(solution, mesh, varFactory);
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
if (steady)
{
solution->solve(false);
if (commRank == 0)
{
stringstream outfile;
outfile << "Convection_" << refIndex;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_hat) );
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
Teuchos::Tuple<double, 3> fluxImbalances = checkConservation(flux, zero, varFactory, mesh);
cout << "Mass flux: Largest Local = " << fluxImbalances[0]
<< ", Global = " << fluxImbalances[1] << ", Sum Abs = " << fluxImbalances[2] << endl;
}
}
else
{
int timestepCount = 0;
double time_tol = 1e-8;
double L2_time_residual = 1e9;
// cout << L2_time_residual <<" "<< time_tol << timestepCount << numTimeSteps << endl;
while((L2_time_residual > time_tol) && (timestepCount < numTimeSteps))
{
solution->solve(false);
// Subtract solutions to get residual
flowResidual->setSolution(solution);
flowResidual->addSolution(prevTimeFlow, -1.0);
L2_time_residual = flowResidual->L2NormOfSolutionGlobal(u->ID());
if (commRank == 0)
{
cout << endl << "Timestep: " << timestepCount << ", dt = " << dt << ", Time residual = " << L2_time_residual << endl;
stringstream outfile;
outfile << "TransientConvection_" << refIndex << "-" << timestepCount;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_hat) );
FunctionPtr source = Teuchos::rcp( new PreviousSolutionFunction(flowResidual, u) );
source = -invDt * source;
Teuchos::Tuple<double, 3> fluxImbalances = checkConservation(flux, source, varFactory, mesh);
cout << "Mass flux: Largest Local = " << fluxImbalances[0]
<< ", Global = " << fluxImbalances[1] << ", Sum Abs = " << fluxImbalances[2] << endl;
}
prevTimeFlow->setSolution(solution); // reset previous time solution to current time sol
timestepCount++;
}
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
return 0;
}
// tests Riesz inversion by integration by parts
bool LinearTermTests::testRieszInversion()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 1;
int pToAdd = 1;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 1;
int horizontalCells = nCells, verticalCells = nCells;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh));
vector<GlobalIndexType> cellIDs;
vector<ElementPtr> elems = myMesh->activeElements();
vector<ElementPtr>::iterator elemIt;
for (elemIt=elems.begin(); elemIt!=elems.end(); elemIt++)
{
int cellID = (*elemIt)->cellID();
cellIDs.push_back(cellID);
}
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(myMesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
LinearTermPtr integrand = Teuchos::rcp(new LinearTerm);// residual
LinearTermPtr integrandIBP = Teuchos::rcp(new LinearTerm);// residual
vector<double> e1(2); // (1,0)
vector<double> e2(2); // (0,1)
e1[0] = 1;
e2[1] = 1;
FunctionPtr n = Function::normal();
FunctionPtr X = Function::xn(1);
FunctionPtr Y = Function::yn(1);
FunctionPtr testFxn1 = X;
FunctionPtr testFxn2 = Y;
FunctionPtr divTestFxn = testFxn1->dx() + testFxn2->dy();
FunctionPtr vectorTest = testFxn1*e1 + testFxn2*e2;
integrand->addTerm(divTestFxn*v);
integrandIBP->addTerm(vectorTest*n*v - vectorTest*v->grad()); // boundary term
IPPtr sobolevIP = Teuchos::rcp(new IP);
sobolevIP->addTerm(v);
sobolevIP->addTerm(tau);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, sobolevIP, integrand));
// riesz->setPrintOption(true);
riesz->computeRieszRep();
Teuchos::RCP<RieszRep> rieszIBP = Teuchos::rcp(new RieszRep(myMesh, sobolevIP, integrandIBP));
riesz->setFunctional(integrandIBP);
// rieszIBP->setPrintOption(true);
rieszIBP->computeRieszRep();
FunctionPtr rieszOrigFxn = RieszRep::repFunction(v,riesz);
FunctionPtr rieszIBPFxn = RieszRep::repFunction(v,rieszIBP);
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numPts = basisCache->getPhysicalCubaturePoints().dimension(1);
FieldContainer<double> valOriginal( numCells, numPts);
FieldContainer<double> valIBP( numCells, numPts);
rieszOrigFxn->values(valOriginal,basisCache);
rieszIBPFxn->values(valIBP,basisCache);
double maxDiff;
double tol = 1e-14;
success = TestSuite::fcsAgree(valOriginal,valIBP,tol,maxDiff);
if (success==false)
{
cout << "Failed TestRieszInversion with maxDiff = " << maxDiff << endl;
}
return success;
}
// tests residual computation on simple convection
bool ScratchPadTests::testLTResidualSimple()
{
double tol = 1e-11;
int rank = Teuchos::GlobalMPISession::getRank();
bool success = true;
int nCells = 2;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// robust test norm
IPPtr ip = Teuchos::rcp(new IP);
// choose the mesh-independent norm even though it may have BLs
ip->addTerm(v->grad());
ip->addTerm(v);
//////////////////// SPECIFY RHS AND HELPFUL FUNCTIONS ///////////////////////
FunctionPtr n = Function::normal();
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
FunctionPtr one = Function::constant(1.0);
FunctionPtr zero = Function::constant(0.0);
RHSPtr rhs = RHS::rhs();
FunctionPtr f = one;
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr boundary = Teuchos::rcp( new InflowSquareBoundary );
FunctionPtr u_in = Teuchos::rcp(new Uinflow);
bc->addDirichlet(beta_n_u, boundary, beta*n*u_in);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int order = 2;
int H1Order = order+1;
int pToAdd = 2;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
int cubEnrich = 0;
Teuchos::RCP<Solution> solution;
solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
double energyError = solution->energyErrorTotal();
LinearTermPtr residual = rhs->linearTermCopy();
residual->addTerm(-confusionBF->testFunctional(solution),true);
Teuchos::RCP<RieszRep> rieszResidual = Teuchos::rcp(new RieszRep(mesh, ip, residual));
rieszResidual->computeRieszRep(cubEnrich);
double energyErrorLT = rieszResidual->getNorm();
bool testVsTest = true;
FunctionPtr e_v = RieszRep::repFunction(v,rieszResidual);
map<int,FunctionPtr> errFxns;
errFxns[v->ID()] = e_v;
FunctionPtr err = (ip->evaluate(errFxns,false))->evaluate(errFxns,false); // don't need boundary terms unless they're in IP
double energyErrorIntegrated = sqrt(err->integrate(mesh,cubEnrich,testVsTest));
// check that energy error computed thru Solution and through rieszRep are the same
success = abs(energyError-energyErrorLT) < tol;
if (success==false)
{
if (rank==0)
cout << "Failed testLTResidualSimple; energy error = " << energyError << ", while linearTerm error is computed to be " << energyErrorLT << endl;
return success;
}
// checks that matrix-computed and integrated errors are the same
success = abs(energyErrorLT-energyErrorIntegrated)<tol;
if (success==false)
{
if (rank==0)
cout << "Failed testLTResidualSimple; energy error = " << energyError << ", while error computed via integration is " << energyErrorIntegrated << endl;
return success;
}
return success;
}
