TEST_F(TransientTests, TestProjection)
{
FunctionPtr u_exact = Teuchos::rcp( new InletBC );
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u_exact;
solution->projectOntoMesh(functionMap);
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr u_sqr = (u_prev - u_exact)*(u_prev - u_exact);
double L2_error_before_ref = sqrt(u_sqr->integrate(mesh));
#ifdef USE_VTK
bool savePlots = false;
VTKExporter exporter(solution, mesh, varFactory);
if (savePlots)
exporter.exportFunction(u_prev, "u_prev");
#endif
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
vector<GlobalIndexType> cellsToRefine;
cellsToRefine.push_back(1);
cellsToRefine.push_back(2);
refinementStrategy.hRefineCells(mesh, cellsToRefine);
#ifdef USE_VTK
if (savePlots)
exporter.exportFunction(u_prev, "u_ref");
#endif
u_sqr = (u_prev - u_exact)*(u_prev - u_exact);
double L2_error_after_ref = sqrt(u_sqr->integrate(mesh));
double tol = 1e-8;
EXPECT_NEAR(L2_error_after_ref, L2_error_before_ref, tol) << "Refinement increases error";
}
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);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
double epsilon = args.Input<double>("--epsilon", "diffusion parameter");
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = modified robust");
// Optional arguments (have defaults)
bool zeroL2 = args.Input("--zeroL2", "take L2 term on v in robust norm to zero", false);
args.Process();
//////////////////// 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 sigma = varFactory.fieldVar("sigma", VECTOR_L2);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma / epsilon, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (norm == 0)
{
ip = bf->graphNorm();
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
ip->addZeroMeanTerm( h2_scaling*v );
}
// Robust norm
else if (norm == 1)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
// Weight these two terms for inflow
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
// Modified robust norm
else if (norm == 2)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
// FunctionPtr ip_weight = Teuchos::rcp( new IPWeight() );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() - beta*v->grad() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
// // robust test norm
// IPPtr robIP = Teuchos::rcp(new IP);
// FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
// if (!enforceLocalConservation)
// robIP->addTerm( ip_scaling * v );
// robIP->addTerm( sqrt(epsilon) * v->grad() );
// // Weight these two terms for inflow
// FunctionPtr ip_weight = Teuchos::rcp( new IPWeight() );
// robIP->addTerm( ip_weight * beta * v->grad() );
// robIP->addTerm( ip_weight * tau->div() );
// robIP->addTerm( ip_scaling/sqrt(epsilon) * tau );
// if (enforceLocalConservation)
// robIP->addZeroMeanTerm( v );
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
SpatialFilterPtr tbBoundary = Teuchos::rcp( new TopBottomBoundary );
SpatialFilterPtr rBoundary = Teuchos::rcp( new RightBoundary );
// SpatialFilterPtr leftCircleBoundary = Teuchos::rcp( new LeftCircleBoundary );
// SpatialFilterPtr rightCircleBoundary = Teuchos::rcp( new RightCircleBoundary );
SpatialFilterPtr circleBoundary = Teuchos::rcp( new CircleBoundary );
bc->addDirichlet(beta_n_u_minus_sigma_n, lBoundary, zero);
bc->addDirichlet(beta_n_u_minus_sigma_n, tbBoundary, zero);
pc->addConstraint(beta*uhat->times_normal() - beta_n_u_minus_sigma_n == zero, rBoundary);
// bc->addDirichlet(uhat, leftCircleBoundary, one);
// bc->addDirichlet(beta_n_u_minus_sigma_n, rightCircleBoundary, beta*n*one);
bc->addDirichlet(uhat, circleBoundary, one);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 3, pToAdd = 2;
Teuchos::RCP<Mesh> mesh;
mesh = MeshFactory::shiftedHemkerMesh(-3, 9, 6, 1, bf, H1Order, pToAdd);
// mesh = BuildHemkerMesh(bf, nseg, circleMesh, triangulateMesh, H1Order, pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->setFilter(pc);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
double energyThreshold = 0.25; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
Teuchos::RCP<RefinementHistory> refHistory = Teuchos::rcp( new RefinementHistory );
mesh->registerObserver(refHistory);
#ifdef saveVTK
VTKExporter exporter(solution, mesh, varFactory);
#endif
ofstream errOut;
if (commRank == 0)
errOut.open("hemker_err.txt");
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
solution->solve(false);
double energy_error = solution->energyErrorTotal();
if (commRank==0)
{
stringstream outfile;
outfile << "hemker_" << refIndex;
#ifdef saveVTK
exporter.exportSolution(outfile.str());
#endif
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_minus_sigma_n) );
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;
errOut << mesh->numGlobalDofs() << " " << energy_error << " "
<< fluxImbalances[0] << " " << fluxImbalances[1] << " " << fluxImbalances[2] << endl;
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
if (commRank == 0)
errOut.close();
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 commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = coupled robust");
// Optional arguments (have defaults)
int uniformRefinements = args.Input("--uniformRefinements", "number of uniform refinements", 0);
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation", false);
double radius = args.Input("--r", "cylinder radius", 0.6);
int Re = args.Input("--Re", "Reynolds number", 1);
int maxNewtonIterations = args.Input("--maxIterations", "maximum number of Newton iterations", 1);
int polyOrder = args.Input("--polyOrder", "polynomial order for field variables", 2);
int deltaP = args.Input("--deltaP", "how much to enrich test space", 2);
// string saveFile = args.Input<string>("--meshSaveFile", "file to which to save refinement history", "");
// string replayFile = args.Input<string>("--meshLoadFile", "file with refinement history to replay", "");
args.Process();
//////////////////// PROBLEM DEFINITIONS ///////////////////////
int H1Order = polyOrder+1;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr tau1 = varFactory.testVar("tau1", HDIV);
VarPtr tau2 = varFactory.testVar("tau2", HDIV);
VarPtr v1 = varFactory.testVar("v1", HGRAD);
VarPtr v2 = varFactory.testVar("v2", HGRAD);
VarPtr vc = varFactory.testVar("vc", HGRAD);
// define trial variables
VarPtr u1 = varFactory.fieldVar("u1");
VarPtr u2 = varFactory.fieldVar("u2");
VarPtr p = varFactory.fieldVar("p");
VarPtr u1hat = varFactory.traceVar("u1hat");
VarPtr u2hat = varFactory.traceVar("u2hat");
VarPtr t1hat = varFactory.fluxVar("t1hat");
VarPtr t2hat = varFactory.fluxVar("t2hat");
VarPtr sigma1 = varFactory.fieldVar("sigma1", VECTOR_L2);
VarPtr sigma2 = varFactory.fieldVar("sigma2", VECTOR_L2);
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshFactory::shiftedHemkerMesh(-1, 3, 2, radius, bf, H1Order, deltaP);
////////////////////////////////////////////////////////////////////
// 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 u1_prev = Function::solution(u1, backgroundFlow);
FunctionPtr u2_prev = Function::solution(u2, backgroundFlow);
FunctionPtr sigma1_prev = Function::solution(sigma1, backgroundFlow);
FunctionPtr sigma2_prev = Function::solution(sigma2, backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
FunctionPtr beta = e1 * u1_prev + e2 * u2_prev;
// ==================== SET INITIAL GUESS ==========================
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u1->ID()] = one;
functionMap[u2->ID()] = zero;
functionMap[sigma1->ID()] = Function::vectorize(zero,zero);
functionMap[sigma2->ID()] = Function::vectorize(zero,zero);
functionMap[p->ID()] = zero;
backgroundFlow->projectOntoMesh(functionMap);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
// // stress equation
bf->addTerm( sigma1, tau1 );
bf->addTerm( sigma2, tau2 );
bf->addTerm( u1, tau1->div() );
bf->addTerm( u2, tau2->div() );
bf->addTerm( -u1hat, tau1->dot_normal() );
bf->addTerm( -u2hat, tau2->dot_normal() );
// momentum equation
// bf->addTerm( Function::xPart(sigma1_prev)*u1, v1 );
// bf->addTerm( Function::yPart(sigma1_prev)*u2, v1 );
// bf->addTerm( Function::xPart(sigma2_prev)*u1, v2 );
// bf->addTerm( Function::yPart(sigma2_prev)*u2, v2 );
// bf->addTerm( beta*sigma1, v1);
// bf->addTerm( beta*sigma2, v2);
bf->addTerm( 1./Re*sigma1, v1->grad() );
bf->addTerm( 1./Re*sigma2, v2->grad() );
bf->addTerm( t1hat, v1);
bf->addTerm( t2hat, v2);
bf->addTerm( -p, v1->dx() );
bf->addTerm( -p, v2->dy() );
// continuity equation
bf->addTerm( -u1, vc->dx() );
bf->addTerm( -u2, vc->dy() );
bf->addTerm( u1hat, vc->times_normal_x() );
bf->addTerm( u2hat, vc->times_normal_y() );
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
// stress equation
rhs->addTerm( -sigma1_prev * tau1 );
rhs->addTerm( -sigma2_prev * tau2 );
rhs->addTerm( -u1_prev * tau1->div() );
rhs->addTerm( -u2_prev * tau2->div() );
// momentum equation
// rhs->addTerm( -beta*sigma1_prev * v1 );
// rhs->addTerm( -beta*sigma2_prev * v2 );
rhs->addTerm( -1./Re*sigma1_prev * v1->grad() );
rhs->addTerm( -1./Re*sigma2_prev * v2->grad() );
// continuity equation
rhs->addTerm( u1_prev * vc->dx() );
rhs->addTerm( u2_prev * vc->dy() );
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (norm == 0)
{
ip = bf->graphNorm();
}
else if (norm == 1)
{
// ip = bf->l2Norm();
}
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
SpatialFilterPtr left = Teuchos::rcp( new ConstantXBoundary(-1) );
SpatialFilterPtr right = Teuchos::rcp( new ConstantXBoundary(3) );
SpatialFilterPtr top = Teuchos::rcp( new ConstantYBoundary(1) );
SpatialFilterPtr bottom = Teuchos::rcp( new ConstantYBoundary(-1) );
SpatialFilterPtr circle = Teuchos::rcp( new CircleBoundary(radius) );
FunctionPtr boundaryU1 = Teuchos::rcp( new BoundaryU1 );
bc->addDirichlet(u1hat, left, boundaryU1);
bc->addDirichlet(u2hat, left, zero);
bc->addDirichlet(u1hat, right, boundaryU1);
bc->addDirichlet(u2hat, right, zero);
bc->addDirichlet(u1hat, top, zero);
bc->addDirichlet(u2hat, top, zero);
bc->addDirichlet(u1hat, bottom, zero);
bc->addDirichlet(u2hat, bottom, zero);
bc->addDirichlet(u1hat, circle, zero);
bc->addDirichlet(u2hat, circle, zero);
// zero mean constraint on pressure
bc->addZeroMeanConstraint(p);
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
if (enforceLocalConservation)
{
solution->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y() == zero);
}
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(backgroundFlow);
// Teuchos::RCP< RefinementHistory > refHistory = Teuchos::rcp( new RefinementHistory );
// mesh->registerObserver(refHistory);
//////////////////// SOLVE & REFINE ///////////////////////
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(backgroundFlow, mesh, varFactory);
ofstream errOut;
ofstream fluxOut;
if (commRank == 0)
{
errOut.open("stokeshemker_err.txt");
fluxOut.open("stokeshemker_flux.txt");
}
errOut.precision(15);
fluxOut.precision(15);
// Cell IDs for flux calculations
vector< pair<ElementPtr, int> > cellFace0;
vector< pair<ElementPtr, int> > cellFace1;
vector< pair<ElementPtr, int> > cellFace2;
vector< pair<ElementPtr, int> > cellFace3;
vector< pair<ElementPtr, int> > cellFace4;
cellFace0.push_back(make_pair(mesh->getElement(12), 3));
cellFace0.push_back(make_pair(mesh->getElement(13), 3));
cellFace0.push_back(make_pair(mesh->getElement(14), 3));
cellFace0.push_back(make_pair(mesh->getElement(15), 3));
cellFace1.push_back(make_pair(mesh->getElement(12), 1));
cellFace1.push_back(make_pair(mesh->getElement(13), 1));
cellFace1.push_back(make_pair(mesh->getElement(14), 1));
cellFace1.push_back(make_pair(mesh->getElement(15), 1));
cellFace2.push_back(make_pair(mesh->getElement(11), 1));
cellFace2.push_back(make_pair(mesh->getElement(2 ), 0));
cellFace2.push_back(make_pair(mesh->getElement(5 ), 2));
cellFace2.push_back(make_pair(mesh->getElement(16), 1));
cellFace3.push_back(make_pair(mesh->getElement(9 ), 3));
cellFace3.push_back(make_pair(mesh->getElement(8 ), 3));
cellFace3.push_back(make_pair(mesh->getElement(19), 3));
cellFace3.push_back(make_pair(mesh->getElement(18), 3));
cellFace4.push_back(make_pair(mesh->getElement(9 ), 1));
cellFace4.push_back(make_pair(mesh->getElement(8 ), 1));
cellFace4.push_back(make_pair(mesh->getElement(19), 1));
cellFace4.push_back(make_pair(mesh->getElement(18), 1));
// // for loading refinement history
// if (replayFile.length() > 0) {
// RefinementHistory refHistory;
// replayFile = replayFile;
// refHistory.loadFromFile(replayFile);
// refHistory.playback(mesh);
// int numElems = mesh->numActiveElements();
// if (commRank==0){
// double minSideLength = meshInfo.getMinCellSideLength() ;
// cout << "after replay, num elems = " << numElems << " and min side length = " << minSideLength << endl;
// }
// }
for (int i = 0; i < uniformRefinements; i++)
refinementStrategy.hRefineUniformly(mesh);
double nonlinearRelativeEnergyTolerance = 1e-5; // used to determine convergence of the nonlinear solution
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
double L2Update = 1e10;
int iterCount = 0;
while (L2Update > nonlinearRelativeEnergyTolerance && iterCount < maxNewtonIterations)
{
solution->solve(false);
double u1L2Update = solution->L2NormOfSolutionGlobal(u1->ID());
double u2L2Update = solution->L2NormOfSolutionGlobal(u2->ID());
L2Update = sqrt(u1L2Update*u1L2Update + u2L2Update*u2L2Update);
double energy_error = solution->energyErrorTotal();
// Check local conservation
if (commRank == 0)
{
FunctionPtr n = Function::normal();
FunctionPtr u1_prev = Function::solution(u1hat, solution);
FunctionPtr u2_prev = Function::solution(u2hat, solution);
FunctionPtr flux = u1_prev*n->x() + u2_prev*n->y();
Teuchos::Tuple<double, 3> fluxImbalances = checkConservation(flux, zero, mesh);
// cout << "Mass flux: Largest Local = " << fluxImbalances[0]
// << ", Global = " << fluxImbalances[1] << ", Sum Abs = " << fluxImbalances[2] << endl;
errOut << mesh->numGlobalDofs() << " " << energy_error << " "
<< fluxImbalances[0] << " " << fluxImbalances[1] << " " << fluxImbalances[2] << endl;
double massFlux0 = computeFluxOverElementSides(u1_prev, mesh, cellFace0);
double massFlux1 = computeFluxOverElementSides(u1_prev, mesh, cellFace1);
double massFlux2 = computeFluxOverElementSides(u1_prev, mesh, cellFace2);
double massFlux3 = computeFluxOverElementSides(u1_prev, mesh, cellFace3);
double massFlux4 = computeFluxOverElementSides(u1_prev, mesh, cellFace4);
fluxOut << massFlux0 << " " << massFlux1 << " " << massFlux2 << " " << massFlux3 << " " << massFlux4 << " " << endl;
cout << "Total mass flux = " << massFlux0 << " " << massFlux1 << " " << massFlux2 << " " << massFlux3 << " " << massFlux4 << " " << endl;
// if (saveFile.length() > 0) {
// std::ostringstream oss;
// oss << string(saveFile) << refIndex ;
// cout << "on refinement " << refIndex << " saving mesh file to " << oss.str() << endl;
// refHistory->saveToFile(oss.str());
// }
}
// line search algorithm
double alpha = 1.0;
// bool useLineSearch = false;
// int posEnrich = 5; // amount of enriching of grid points on which to ensure positivity
// if (useLineSearch){ // to enforce positivity of density rho
// double lineSearchFactor = .5; double eps = .001; // arbitrary
// FunctionPtr rhoTemp = Function::solution(rho,backgroundFlow) + alpha*Function::solution(rho,solution) - Function::constant(eps);
// FunctionPtr eTemp = Function::solution(e,backgroundFlow) + alpha*Function::solution(e,solution) - Function::constant(eps);
// bool rhoIsPositive = rhoTemp->isPositive(mesh,posEnrich);
// bool eIsPositive = eTemp->isPositive(mesh,posEnrich);
// int iter = 0; int maxIter = 20;
// while (!(rhoIsPositive && eIsPositive) && iter < maxIter){
// alpha = alpha*lineSearchFactor;
// rhoTemp = Function::solution(rho,backgroundFlow) + alpha*Function::solution(rho,solution);
// eTemp = Function::solution(e,backgroundFlow) + alpha*Function::solution(e,solution);
// rhoIsPositive = rhoTemp->isPositive(mesh,posEnrich);
// eIsPositive = eTemp->isPositive(mesh,posEnrich);
// iter++;
// }
// if (commRank==0 && alpha < 1.0){
// cout << "line search factor alpha = " << alpha << endl;
// }
// }
backgroundFlow->addSolution(solution, alpha, false, true);
iterCount++;
// if (commRank == 0)
// cout << "L2 Norm of Update = " << L2Update << endl;
}
if (commRank == 0)
cout << endl;
if (commRank == 0)
{
stringstream outfile;
outfile << "stokeshemker" << uniformRefinements << "_" << refIndex;
exporter.exportSolution(outfile.str());
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
if (commRank == 0)
{
errOut.close();
fluxOut.close();
}
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
//////////////////// 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("uhat");
VarPtr sigma_n = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("sigma1");
VarPtr sigma2 = varFactory.fieldVar("sigma2");
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma1, tau->x());
bf->addTerm(sigma2, tau->y());
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma1, v->dx() );
bf->addTerm( sigma2, v->dy() );
bf->addTerm( -sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(1.0) );
rhs->addTerm( f * v );
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
SpatialFilterPtr inflow = Teuchos::rcp( new Inflow );
bc->addDirichlet(uhat, inflow, zero);
SpatialFilterPtr leadingWedge = Teuchos::rcp( new LeadingWedge );
bc->addDirichlet(uhat, leadingWedge, zero);
SpatialFilterPtr trailingWedge = Teuchos::rcp( new TrailingWedge );
bc->addDirichlet(sigma_n, trailingWedge, zero);
// bc->addDirichlet(uhat, trailingWedge, zero);
SpatialFilterPtr top = Teuchos::rcp( new Top );
bc->addDirichlet(uhat, top, zero);
SpatialFilterPtr outflow = Teuchos::rcp( new Outflow );
bc->addDirichlet(uhat, outflow, zero);
//////////////////// BUILD MESH ///////////////////////
bool allQuads = true;
int H1Order = 3, pToAdd = 2;
// define nodes for mesh
vector< FieldContainer<double> > vertices;
FieldContainer<double> pt(2);
vector< vector<int> > elementIndices;
vector<int> q(4);
vector<int> t(3);
if (allQuads)
{
pt(0) = -halfwidth;
pt(1) = -1;
vertices.push_back(pt);
pt(0) = 0;
pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth;
pt(1) = -1;
vertices.push_back(pt);
pt(0) = halfwidth;
pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = 0;
pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth;
pt(1) = halfwidth;
vertices.push_back(pt);
q[0] = 0;
q[1] = 1;
q[2] = 4;
q[3] = 5;
elementIndices.push_back(q);
q[0] = 1;
q[1] = 2;
q[2] = 3;
q[3] = 4;
elementIndices.push_back(q);
}
else
{
pt(0) = -halfwidth;
pt(1) = -1;
vertices.push_back(pt);
pt(0) = 0;
pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth;
pt(1) = -1;
vertices.push_back(pt);
pt(0) = halfwidth;
pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth;
pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = 0;
pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth;
pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth;
pt(1) = 0;
vertices.push_back(pt);
t[0] = 0;
t[1] = 1;
t[2] = 7;
elementIndices.push_back(t);
t[0] = 1;
t[1] = 2;
t[2] = 3;
elementIndices.push_back(t);
q[0] = 1;
q[1] = 3;
q[2] = 4;
q[3] = 5;
elementIndices.push_back(q);
q[0] = 7;
q[1] = 1;
q[2] = 5;
q[3] = 6;
elementIndices.push_back(q);
}
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh(vertices, elementIndices, bf, H1Order, pToAdd) );
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->setFilter(pc);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(sigma_n == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
solution->solve(false);
if (rank==0)
{
stringstream outfile;
outfile << "poissonwedge_" << refIndex;
solution->writeToVTK(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma_n) );
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;
}
if (refIndex < numRefs)
{
// refinementStrategy.refine(rank==0); // print to console on rank 0
vector<int> cellsToRefine;
vector<int> cells_h;
vector<int> cells_p;
refinementStrategy.getCellsAboveErrorThreshhold(cellsToRefine);
for (int i=0; i < cellsToRefine.size(); i++)
if (sqrt(mesh->getCellMeasure(cellsToRefine[i])) < 1e-3)
{
int pOrder = mesh->cellPolyOrder(cellsToRefine[i]);
if (allQuads)
cells_p.push_back(cellsToRefine[i]);
else if (pOrder < 8)
cells_p.push_back(cellsToRefine[i]);
else
cout << "Reached cell size and polynomial order limits" << endl;
// cells_h.push_back(cellsToRefine[i]);
}
else
cells_h.push_back(cellsToRefine[i]);
refinementStrategy.pRefineCells(mesh, cells_p);
refinementStrategy.hRefineCells(mesh, cells_h);
}
}
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 commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
double epsilon = args.Input<double>("--epsilon", "diffusion parameter");
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = modified robust");
// Optional arguments (have defaults)
halfwidth = args.Input("--halfwidth", "half the width of the wedge", 0.5);
bool allQuads = args.Input("--allQuads", "use only quads in mesh", false);
bool zeroL2 = args.Input("--zeroL2", "take L2 term on v in robust norm to zero", enforceLocalConservation);
args.Process();
//////////////////// 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("uhat");
VarPtr beta_n_u_minus_sigma_n = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma = varFactory.fieldVar("sigma", VECTOR_L2);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma / epsilon, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
// Graph norm
if (norm == 0)
{
ip = bf->graphNorm();
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
ip->addZeroMeanTerm( h2_scaling*v );
}
// Robust norm
else if (norm == 1)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
// Weight these two terms for inflow
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
// Modified robust norm
else if (norm == 2)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
ip->addTerm( tau->div() - beta*v->grad() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
SpatialFilterPtr inflow = Teuchos::rcp( new Inflow );
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
bc->addDirichlet(beta_n_u_minus_sigma_n, inflow, zero);
SpatialFilterPtr leadingWedge = Teuchos::rcp( new LeadingWedge );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
bc->addDirichlet(uhat, leadingWedge, one);
SpatialFilterPtr trailingWedge = Teuchos::rcp( new TrailingWedge );
bc->addDirichlet(beta_n_u_minus_sigma_n, trailingWedge, beta*n*one);
// bc->addDirichlet(uhat, trailingWedge, one);
SpatialFilterPtr top = Teuchos::rcp( new Top );
bc->addDirichlet(uhat, top, zero);
// bc->addDirichlet(beta_n_u_minus_sigma_n, top, zero);
SpatialFilterPtr outflow = Teuchos::rcp( new Outflow );
pc->addConstraint(beta*uhat->times_normal() - beta_n_u_minus_sigma_n == zero, outflow);
//////////////////// BUILD MESH ///////////////////////
int H1Order = 3, pToAdd = 2;
// define nodes for mesh
vector< FieldContainer<double> > vertices;
FieldContainer<double> pt(2);
vector< vector<int> > elementIndices;
vector<int> q(4);
vector<int> t(3);
if (allQuads)
{
pt(0) = -halfwidth; pt(1) = -1;
vertices.push_back(pt);
pt(0) = 0; pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth; pt(1) = -1;
vertices.push_back(pt);
pt(0) = halfwidth; pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = 0; pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth; pt(1) = halfwidth;
vertices.push_back(pt);
q[0] = 0; q[1] = 1; q[2] = 4; q[3] = 5;
elementIndices.push_back(q);
q[0] = 1; q[1] = 2; q[2] = 3; q[3] = 4;
elementIndices.push_back(q);
}
else
{
pt(0) = -halfwidth; pt(1) = -1;
vertices.push_back(pt);
pt(0) = 0; pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth; pt(1) = -1;
vertices.push_back(pt);
pt(0) = halfwidth; pt(1) = 0;
vertices.push_back(pt);
pt(0) = halfwidth; pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = 0; pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth; pt(1) = halfwidth;
vertices.push_back(pt);
pt(0) = -halfwidth; pt(1) = 0;
vertices.push_back(pt);
t[0] = 0; t[1] = 1; t[2] = 7;
elementIndices.push_back(t);
t[0] = 1; t[1] = 2; t[2] = 3;
elementIndices.push_back(t);
q[0] = 1; q[1] = 3; q[2] = 4; q[3] = 5;
elementIndices.push_back(q);
q[0] = 7; q[1] = 1; q[2] = 5; q[3] = 6;
elementIndices.push_back(q);
}
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh(vertices, elementIndices, bf, H1Order, pToAdd) );
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->setFilter(pc);
if (enforceLocalConservation) {
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(solution, mesh, varFactory);
ofstream errOut;
if (commRank == 0)
errOut.open("singularwedge_err.txt");
for (int refIndex=0; refIndex<=numRefs; refIndex++){
solution->solve(false);
double energy_error = solution->energyErrorTotal();
if (commRank==0){
stringstream outfile;
outfile << "singularwedge_" << refIndex;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_minus_sigma_n) );
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;
errOut << mesh->numGlobalDofs() << " " << energy_error << " "
<< fluxImbalances[0] << " " << fluxImbalances[1] << " " << fluxImbalances[2] << endl;
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
if (commRank == 0)
errOut.close();
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 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;
}
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;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
#endif
{
// 1D tests
CellTopoPtr line_2 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Line<2> >() ) );
// let's draw a line
vector<double> v0 = makeVertex(0);
vector<double> v1 = makeVertex(1);
vector<double> v2 = makeVertex(2);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vector<unsigned> line1VertexList;
vector<unsigned> line2VertexList;
line1VertexList.push_back(0);
line1VertexList.push_back(1);
line2VertexList.push_back(1);
line2VertexList.push_back(2);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(line1VertexList);
elementVertices.push_back(line2VertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(line_2);
cellTopos.push_back(line_2);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x = Function::xn(1);
FunctionPtr function = x;
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(function);
vector<string> functionNames;
functionNames.push_back("function1");
functionNames.push_back("function2");
{
XDMFExporter exporter(meshTopology, "function1", false);
exporter.exportFunction(function, "function1");
}
{
XDMFExporter exporter(meshTopology, "boundary1", false);
exporter.exportFunction(fbdr, "boundary1");
}
{
XDMFExporter exporter(meshTopology, "functions1", false);
exporter.exportFunction(functions, functionNames);
}
}
{
// 2D tests
CellTopoPtr quad_4 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ) );
CellTopoPtr tri_3 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Triangle<3> >() ) );
// let's draw a little house
vector<double> v0 = makeVertex(-1,0);
vector<double> v1 = makeVertex(1,0);
vector<double> v2 = makeVertex(1,2);
vector<double> v3 = makeVertex(-1,2);
vector<double> v4 = makeVertex(0.0,3);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
vertices.push_back(v4);
vector<unsigned> quadVertexList;
quadVertexList.push_back(0);
quadVertexList.push_back(1);
quadVertexList.push_back(2);
quadVertexList.push_back(3);
vector<unsigned> triVertexList;
triVertexList.push_back(3);
triVertexList.push_back(2);
triVertexList.push_back(4);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(quadVertexList);
elementVertices.push_back(triVertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(quad_4);
cellTopos.push_back(tri_3);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x2 = Function::xn(2);
FunctionPtr y2 = Function::yn(2);
FunctionPtr function = x2 + y2;
FunctionPtr vect = Function::vectorize(x2, y2);
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(vect);
vector<string> functionNames;
functionNames.push_back("function");
functionNames.push_back("vect");
vector<FunctionPtr> bdrfunctions;
bdrfunctions.push_back(fbdr);
bdrfunctions.push_back(fbdr);
vector<string> bdrfunctionNames;
bdrfunctionNames.push_back("bdr1");
bdrfunctionNames.push_back("bdr2");
map<int, int> cellIDToNum1DPts;
cellIDToNum1DPts[1] = 4;
{
XDMFExporter exporter(meshTopology, "Grid2D", false);
// exporter.exportFunction(function, "function2", 0, 10);
// exporter.exportFunction(vect, "vect2", 1, 10, cellIDToNum1DPts);
// exporter.exportFunction(fbdr, "boundary2", 0);
exporter.exportFunction(functions, functionNames, 1, 10);
}
{
XDMFExporter exporter(meshTopology, "BdrGrid2D", false);
// exporter.exportFunction(function, "function2", 0, 10);
// exporter.exportFunction(vect, "vect2", 1, 10, cellIDToNum1DPts);
// exporter.exportFunction(fbdr, "boundary2", 0);
exporter.exportFunction(bdrfunctions, bdrfunctionNames, 1, 10);
}
//////////////////// 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("uhat");
VarPtr fhat = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma = varFactory.fieldVar("sigma", VECTOR_L2);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( fhat, v);
//////////////////// BUILD MESH ///////////////////////
int H1Order = 4, pToAdd = 2;
Teuchos::RCP<Mesh> mesh = Teuchos::rcp( new Mesh (meshTopology, bf, H1Order, pToAdd) );
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
//////////////////// SPECIFY RHS ///////////////////////
RHSPtr rhs = RHS::rhs();
// Teuchos::RCP<RHS> rhs = Teuchos::rcp( new RHS );
FunctionPtr one = Function::constant(1.0);
rhs->addTerm( one * v );
//////////////////// CREATE BCs ///////////////////////
// Teuchos::RCP<BC> bc = Teuchos::rcp( new BCEasy );
BCPtr bc = BC::bc();
FunctionPtr zero = Function::zero();
SpatialFilterPtr entireBoundary = Teuchos::rcp( new EntireBoundary );
bc->addDirichlet(uhat, entireBoundary, zero);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
solution->solve(false);
RefinementStrategy refinementStrategy( solution, 0.2);
// Output solution
FunctionPtr uSoln = Function::solution(u, solution);
FunctionPtr sigmaSoln = Function::solution(sigma, solution);
FunctionPtr uhatSoln = Function::solution(uhat, solution);
FunctionPtr fhatSoln = Function::solution(fhat, solution);
{
XDMFExporter exporter(meshTopology, "Poisson", false);
exporter.exportFunction(uSoln, "u", 0, 4);
exporter.exportFunction(uSoln, "u", 1, 5);
exporter.exportFunction(uhatSoln, "uhat", 0, 4);
exporter.exportFunction(uhatSoln, "uhat", 1, 5);
// exporter.exportFunction(fhatSoln, "fhat", 0, 4);
// exporter.exportFunction(fhatSoln, "fhat", 1, 5);
}
{
XDMFExporter exporter(meshTopology, "PoissonSolution", false);
exporter.exportSolution(solution, mesh, varFactory, 0, 2, cellIDToSubdivision(mesh, 10));
refinementStrategy.refine(true);
solution->solve(false);
exporter.exportSolution(solution, mesh, varFactory, 1, 2, cellIDToSubdivision(mesh, 10));
}
// exporter.exportFunction(sigmaSoln, "Poisson-s", "sigma", 0, 5);
// exporter.exportFunction(uhatSoln, "Poisson-uhat", "uhat", 1, 6);
}
{
// 3D tests
CellTopoPtr hex = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >() ));
// let's draw a little box
vector<double> v0 = makeVertex(0,0,0);
vector<double> v1 = makeVertex(1,0,0);
vector<double> v2 = makeVertex(1,1,0);
vector<double> v3 = makeVertex(0,1,0);
vector<double> v4 = makeVertex(0,0,1);
vector<double> v5 = makeVertex(1,0,1);
vector<double> v6 = makeVertex(1,1,1);
vector<double> v7 = makeVertex(0,1,1);
vector< vector<double> > vertices;
vertices.push_back(v0);
vertices.push_back(v1);
vertices.push_back(v2);
vertices.push_back(v3);
vertices.push_back(v4);
vertices.push_back(v5);
vertices.push_back(v6);
vertices.push_back(v7);
vector<unsigned> hexVertexList;
hexVertexList.push_back(0);
hexVertexList.push_back(1);
hexVertexList.push_back(2);
hexVertexList.push_back(3);
hexVertexList.push_back(4);
hexVertexList.push_back(5);
hexVertexList.push_back(6);
hexVertexList.push_back(7);
// vector<unsigned> triVertexList;
// triVertexList.push_back(2);
// triVertexList.push_back(3);
// triVertexList.push_back(4);
vector< vector<unsigned> > elementVertices;
elementVertices.push_back(hexVertexList);
// elementVertices.push_back(triVertexList);
vector< CellTopoPtr > cellTopos;
cellTopos.push_back(hex);
// cellTopos.push_back(tri_3);
MeshGeometryPtr meshGeometry = Teuchos::rcp( new MeshGeometry(vertices, elementVertices, cellTopos) );
MeshTopologyPtr meshTopology = Teuchos::rcp( new MeshTopology(meshGeometry) );
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr z = Function::zn(1);
FunctionPtr function = x + y + z;
FunctionPtr fbdr = Function::restrictToCellBoundary(function);
FunctionPtr vect = Function::vectorize(x, y, z);
vector<FunctionPtr> functions;
functions.push_back(function);
functions.push_back(vect);
vector<string> functionNames;
functionNames.push_back("function");
functionNames.push_back("vect");
{
XDMFExporter exporter(meshTopology, "function3", false);
exporter.exportFunction(function, "function3");
}
{
XDMFExporter exporter(meshTopology, "boundary3", false);
exporter.exportFunction(fbdr, "boundary3");
}
{
XDMFExporter exporter(meshTopology, "vect3", false);
exporter.exportFunction(vect, "vect3");
}
{
XDMFExporter exporter(meshTopology, "functions3", false);
exporter.exportFunction(functions, functionNames);
}
}
}
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
//////////////////// 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_const;
beta_const.push_back(1.0);
beta_const.push_back(0.0);
// FunctionPtr beta = Teuchos::rcp(new Beta());
double eps = 1e-2;
//////////////////// 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( beta_const * u, - v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// mathematician's norm
IPPtr mathIP = Teuchos::rcp(new IP());
mathIP->addTerm(tau);
mathIP->addTerm(tau->div());
mathIP->addTerm(v);
mathIP->addTerm(v->grad());
// quasi-optimal norm
IPPtr qoptIP = Teuchos::rcp(new IP);
qoptIP->addTerm( v );
qoptIP->addTerm( tau / eps + v->grad() );
qoptIP->addTerm( beta_const * v->grad() - tau->div() );
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(eps) );
if (enforceLocalConservation)
{
robIP->addZeroMeanTerm( v );
}
else
{
robIP->addTerm( ip_scaling * v );
}
robIP->addTerm( sqrt(eps) * v->grad() );
robIP->addTerm( beta_const * v->grad() );
robIP->addTerm( tau->div() );
robIP->addTerm( ip_scaling/sqrt(eps) * tau );
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = zero;
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 );
SpatialFilterPtr inflowTop = Teuchos::rcp(new InflowLshapeTop);
SpatialFilterPtr inflowBot = Teuchos::rcp(new InflowLshapeBottom);
SpatialFilterPtr LshapeBot1 = Teuchos::rcp(new LshapeBottom1);
SpatialFilterPtr LshapeBot2 = Teuchos::rcp(new LshapeBottom2);
SpatialFilterPtr Top = Teuchos::rcp(new LshapeTop);
SpatialFilterPtr Out = Teuchos::rcp(new LshapeOutflow);
FunctionPtr u0 = Teuchos::rcp( new U0 );
bc->addDirichlet(uhat, LshapeBot1, u0);
bc->addDirichlet(uhat, LshapeBot2, u0);
bc->addDirichlet(uhat, Top, u0);
bc->addDirichlet(uhat, Out, u0);
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
// bc->addDirichlet(uhat, inflowBot, u0);
FunctionPtr u0Top = Teuchos::rcp(new ParabolicProfile);
FunctionPtr u0Bot = Teuchos::rcp(new LinearProfile);
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowTop, beta_const*n*u0Top);
// bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBot, beta_const*n*u0Bot);
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBot, beta_const*n*zero);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 2, 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 horizontalCells = 1, verticalCells = 1;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
*/
Teuchos::RCP<Mesh> mesh;
// L-shaped domain for double ramp problem
FieldContainer<double> A(2), B(2), C(2), D(2), E(2), F(2), G(2), H(2);
A(0) = 0.0;
A(1) = 0.5;
B(0) = 0.0;
B(1) = 1.0;
C(0) = 0.5;
C(1) = 1.0;
D(0) = 1.0;
D(1) = 1.0;
E(0) = 1.0;
E(1) = 0.5;
F(0) = 1.0;
F(1) = 0.0;
G(0) = 0.5;
G(1) = 0.0;
H(0) = 0.5;
H(1) = 0.5;
vector<FieldContainer<double> > vertices;
vertices.push_back(A);
int A_index = 0;
vertices.push_back(B);
int B_index = 1;
vertices.push_back(C);
int C_index = 2;
vertices.push_back(D);
int D_index = 3;
vertices.push_back(E);
int E_index = 4;
vertices.push_back(F);
int F_index = 5;
vertices.push_back(G);
int G_index = 6;
vertices.push_back(H);
int H_index = 7;
vector< vector<int> > elementVertices;
vector<int> el1, el2, el3, el4, el5;
// left patch:
el1.push_back(A_index);
el1.push_back(H_index);
el1.push_back(C_index);
el1.push_back(B_index);
// top right:
el2.push_back(H_index);
el2.push_back(E_index);
el2.push_back(D_index);
el2.push_back(C_index);
// bottom right:
el3.push_back(G_index);
el3.push_back(F_index);
el3.push_back(E_index);
el3.push_back(H_index);
elementVertices.push_back(el1);
elementVertices.push_back(el2);
elementVertices.push_back(el3);
mesh = Teuchos::rcp( new Mesh(vertices, elementVertices, confusionBF, H1Order, pToAdd) );
//////////////////// SOLVE & REFINE ///////////////////////
// Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, qoptIP) );
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
// solution->setFilter(pc);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
int numRefs = 8;
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
solution->solve(false);
refinementStrategy.refine(rank==0); // print to console on rank 0
}
// one more solve on the final refined mesh:
solution->solve(false);
if (rank==0)
{
solution->writeToVTK("step.vtu",min(H1Order+1,4));
solution->writeFluxesToFile(uhat->ID(), "uhat.dat");
cout << "wrote files: u.m, uhat.dat\n";
}
return 0;
}
int main(int argc, char *argv[]) {
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
int rank=mpiSession.getRank();
int numProcs=mpiSession.getNProc();
#else
choice::Args args( argc, argv );
int rank = 0;
int numProcs = 1;
#endif
int nCells = args.Input<int>("--nCells", "num cells",2);
int numRefs = args.Input<int>("--numRefs","num adaptive refinements",0);
double eps = args.Input<double>("--epsilon","diffusion parameter",1e-2);
double energyThreshold = args.Input<double>("--energyThreshold","adaptivity thresh",.5);
if (rank==0){
cout << "nCells = " << nCells << ", numRefs = " << numRefs << ", eps = " << eps << endl;
}
//////////////////// 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);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// quasi-optimal norm
IPPtr qoptIP = Teuchos::rcp(new IP);
qoptIP->addTerm( v );
qoptIP->addTerm( tau / eps + v->grad() );
qoptIP->addTerm( beta * v->grad() - tau->div() );
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(eps) );
FunctionPtr invSqrtH = Teuchos::rcp(new InvSqrtHScaling);
robIP->addTerm( ip_scaling * v);
robIP->addTerm( ip_scaling/sqrt(eps) * tau );
robIP->addTerm( sqrt(eps) * v->grad() );
robIP->addTerm( beta * v->grad() );
robIP->addTerm( tau->div() );
/*
robIP->addTerm(v);
robIP->addTerm(v->grad());
robIP->addTerm(tau->div());
robIP->addTerm(invSqrtH*tau);
*/
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling ); // see what effect this has
// robIP->addZeroMeanTerm( h2_scaling*v );
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
// FunctionPtr f = zero;
// 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(beta) );
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new OutflowSquareBoundary);
FunctionPtr u_exact = Teuchos::rcp( new Uex(eps,0) );
FunctionPtr sig1_exact = Teuchos::rcp( new Uex(eps,1) );
FunctionPtr sig2_exact = Teuchos::rcp( new Uex(eps,2) );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
vector<double> e1(2); // (1,0)
vector<double> e2(2); // (0,1)
e1[0] = 1;
e2[1] = 1;
FunctionPtr sigma = sig1_exact*e1 + sig2_exact*e2;
bc->addDirichlet(uhat, outflowBoundary, zero);
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta*n*u_exact-sigma*n);
// bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta*n*u_exact); // ignoring sigma
FunctionPtr u_disc = Teuchos::rcp( new Udisc );
// bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta*n*u_disc);
// bc->addDirichlet(uhat, inflowBoundary, u_exact);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 2, pToAdd = 3;
int horizontalCells = nCells, verticalCells = nCells;
// 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, robIP) );
// solution = Teuchos::rcp( new Solution(mesh, bc, rhs, qoptIP) );
if (enforceLocalConservation) {
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
RefinementStrategy refinementStrategy( solution, energyThreshold );
ofstream convOut;
stringstream convOutFile;
convOutFile << "erickson_conv_" << round(-log(eps)/log(10.0)) <<".txt";
convOut.open(convOutFile.str().c_str());
for (int refIndex=0; refIndex < numRefs; refIndex++){
solution->condensedSolve(false);
// solution->solve(false);
double quadTol = 1e-7;
int cubEnrich = 25;
FunctionPtr u_soln = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr sigma1_soln = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma1) );
FunctionPtr sigma2_soln = Teuchos::rcp( new PreviousSolutionFunction(solution, sigma2) );
FunctionPtr u_diff = (u_soln - u_exact)*(u_soln - u_exact);
FunctionPtr sig1_diff = (sigma1_soln - sig1_exact)*(sigma1_soln - sig1_exact);
FunctionPtr sig2_diff = (sigma2_soln - sig2_exact)*(sigma2_soln - sig2_exact);
double u_L2_error = u_diff->integrate(mesh,cubEnrich);
double sigma_L2_error = sig1_diff->integrate(mesh,cubEnrich) + sig2_diff->integrate(mesh,cubEnrich);
double L2_error = sqrt(u_L2_error + sigma_L2_error);
double energy_error = solution->energyErrorTotal();
u_soln->writeValuesToMATLABFile(mesh, "u_soln.m");
u_diff->writeValuesToMATLABFile(mesh, "u_diff.m");
u_exact->writeValuesToMATLABFile(mesh, "u_exact.m");
sig1_exact->writeValuesToMATLABFile(mesh, "s1_exact.m");
sig2_exact->writeValuesToMATLABFile(mesh, "s2_exact.m");
convOut << mesh->numGlobalDofs() << " " << L2_error << " " << energy_error << endl;
if (rank==0){
cout << "L2 error = " << L2_error << ", energy error = " << energy_error << ", ratio = " << L2_error/energy_error << endl;
cout << "u squared L2 error = " << u_L2_error << ", sigma squared l2 error = " << sigma_L2_error << ", num dofs = " << mesh->numGlobalDofs() << endl;
}
refinementStrategy.refine(rank==0); // print to console on rank 0
}
convOut.close();
// one more solve on the final refined mesh:
solution->condensedSolve(false);
VTKExporter exporter(solution, mesh, varFactory);
if (rank==0){
exporter.exportSolution("robustIP");
cout << endl;
}
return 0;
/*
// determine trialIDs
vector< int > trialIDs = mesh->bilinearForm()->trialIDs();
vector< int > fieldIDs;
vector< int > fluxIDs;
vector< int >::iterator idIt;
for (idIt = trialIDs.begin();idIt!=trialIDs.end();idIt++){
int trialID = *(idIt);
if (!mesh->bilinearForm()->isFluxOrTrace(trialID)){ // if field
fieldIDs.push_back(trialID);
} else {
fluxIDs.push_back(trialID);
}
}
int numFieldInds = 0;
map<int,vector<int> > globalFluxInds; // from cellID to localDofInd vector
map<int,vector<int> > globalFieldInds; // from cellID to localDofInd vector
map<int,vector<int> > localFieldInds; // from cellID to localDofInd vector
map<int,vector<int> > localFluxInds; // from cellID to localDofInd vector
set<int> allFluxInds; // unique set of all flux inds
mesh->getDofIndices(allFluxInds,globalFluxInds,globalFieldInds,localFluxInds,localFieldInds);
if (rank==0){
vector< ElementPtr > activeElems = mesh->activeElements();
vector< ElementPtr >::iterator elemIt;
cout << "num flux dofs = " << allFluxInds.size() << endl;
cout << "num field dofs = " << mesh->numFieldDofs() << endl;
cout << "num flux dofs = " << mesh->numFluxDofs() << endl;
elemIt = activeElems.begin();
int cellID = (*elemIt)->cellID();
cout << "num LOCAL field dofs = " << localFieldInds[cellID].size() << endl;
ofstream fieldInds;
fieldInds.open("fieldInds.dat");
for (elemIt = activeElems.begin();elemIt!=activeElems.end();elemIt++){
int cellID = (*elemIt)->cellID();
vector<int> inds = globalFieldInds[cellID];
vector<int> locFieldInds = localFieldInds[cellID];
cout << "local field inds for cell ID " << cellID << endl;
for (int i = 0;i<inds.size();++i){
fieldInds << inds[i]+1 << endl;
cout << locFieldInds[i] << endl;
}
vector<int> finds = globalFluxInds[cellID];
vector<int> locFluxInds = localFluxInds[cellID];
cout << "local flux inds for cell ID " << cellID << endl;
for (int i = 0;i<finds.size();++i){
cout << locFluxInds[i] << endl;
}
cout << "global flux inds for cell ID " << cellID << endl;
for (int i = 0;i<finds.size();++i){
cout << globalFluxInds[cellID][i] << endl;
}
}
fieldInds.close();
ofstream fluxInds;
fluxInds.open("fluxInds.dat");
set<int>::iterator fluxIt;
for (fluxIt = allFluxInds.begin();fluxIt!=allFluxInds.end();fluxIt++){
fluxInds << (*fluxIt)+1 << endl; // offset by 1 for matlab
}
fluxInds.close();
}
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
//////////////////// 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_const;
double c = sqrt(1.25);
beta_const.push_back(1.0/c);
beta_const.push_back(.5/c);
// FunctionPtr beta = Teuchos::rcp(new Beta());
double eps = 1e-3;
//////////////////// 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( beta_const * u, - v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
// quasi-optimal norm
IPPtr qoptIP = Teuchos::rcp(new IP);
qoptIP->addTerm( v );
qoptIP->addTerm( tau / eps + v->grad() );
qoptIP->addTerm( beta_const * v->grad() - tau->div() );
// robust test norm
IPPtr robIP = Teuchos::rcp(new IP);
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(eps) );
if (enforceLocalConservation)
{
robIP->addZeroMeanTerm( v );
}
else
{
robIP->addTerm( ip_scaling * v );
}
robIP->addTerm( sqrt(eps) * v->grad() );
bool useNewBC = false;
FunctionPtr weight = Teuchos::rcp( new SqrtWeight(eps) );
if (useNewBC)
{
robIP->addTerm( beta_const * v->grad() );
robIP->addTerm( tau->div() );
robIP->addTerm( ip_scaling/sqrt(eps) * tau );
}
else
{
robIP->addTerm( weight * beta_const * v->grad() );
robIP->addTerm( weight * tau->div() );
robIP->addTerm( weight * ip_scaling/sqrt(eps) * tau );
}
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = zero;
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 );
FunctionPtr u0 = Teuchos::rcp( new U0 );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
bc->addDirichlet(uhat, outflowBoundary, zero);
if (useNewBC)
{
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowBoundary, beta_const*n*u0);
}
else
{
SpatialFilterPtr inflowBot = Teuchos::rcp( new InflowSquareBot );
SpatialFilterPtr inflowLeft = Teuchos::rcp( new InflowSquareLeft );
bc->addDirichlet(beta_n_u_minus_sigma_n, inflowLeft, beta_const*n*u0);
bc->addDirichlet(uhat, inflowBot, u0);
}
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp(new PenaltyConstraints);
// pc->addConstraint(uhat==u0,inflowBoundary);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 2, 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 pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
// solution->setFilter(pc);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
int numRefs = 9;
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
solution->solve(false);
refinementStrategy.refine(rank==0); // print to console on rank 0
}
// one more solve on the final refined mesh:
solution->solve(false);
if (rank==0)
{
solution->writeToVTK("Hughes.vtu",min(H1Order+1,4));
solution->writeFluxesToFile(uhat->ID(), "uhat.dat");
cout << "wrote files: u.m, uhat.dat\n";
}
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 commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
double epsilon = args.Input<double>("--epsilon", "diffusion parameter");
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
bool graphNorm = args.Input<bool>("--graphNorm", "use the graph norm rather than robust test norm");
// Optional arguments (have defaults)
bool highLiftAirfoil = args.Input("--highLift", "use high lift airfoil rather than NACA0012", false);
args.Process();
//////////////////// 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("uhat");
VarPtr beta_n_u_minus_sigma_n = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma = varFactory.fieldVar("sigma", VECTOR_L2);
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.25);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// tau terms:
bf->addTerm(sigma / epsilon, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (graphNorm)
{
ip = bf->graphNorm();
}
else
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
if (!enforceLocalConservation)
ip->addTerm( ip_scaling * v );
ip->addTerm( sqrt(epsilon) * v->grad() );
// Weight these two terms for inflow
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (enforceLocalConservation)
ip->addZeroMeanTerm( v );
}
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
SpatialFilterPtr tBoundary = Teuchos::rcp( new TopBoundary );
SpatialFilterPtr bBoundary = Teuchos::rcp( new BottomBoundary );
SpatialFilterPtr rBoundary = Teuchos::rcp( new RightBoundary );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
SpatialFilterPtr airfoilInflowBoundary = Teuchos::rcp( new AirfoilInflowBoundary(beta) );
SpatialFilterPtr airfoilOutflowBoundary = Teuchos::rcp( new AirfoilOutflowBoundary(beta) );
FunctionPtr u0 = Teuchos::rcp( new ZeroBC );
FunctionPtr u1 = Teuchos::rcp( new OneBC );
bc->addDirichlet(beta_n_u_minus_sigma_n, lBoundary, u0);
bc->addDirichlet(beta_n_u_minus_sigma_n, bBoundary, u0);
// bc->addDirichlet(uhat, airfoilInflowBoundary, u1);
// bc->addDirichlet(uhat, tBoundary, u0);
bc->addDirichlet(beta_n_u_minus_sigma_n, airfoilInflowBoundary, beta*n*u1);
bc->addDirichlet(uhat, airfoilOutflowBoundary, u1);
// pc->addConstraint(beta*uhat->times_normal() - beta_n_u_minus_sigma_n == u0, rBoundary);
// pc->addConstraint(beta*uhat->times_normal() - beta_n_u_minus_sigma_n == u0, tBoundary);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 3, pToAdd = 2;
Teuchos::RCP<Mesh> mesh;
if (highLiftAirfoil)
mesh = Mesh::readTriangle(Camellia_MeshDir+"HighLift/HighLift.1", bf, H1Order, pToAdd);
else
mesh = Mesh::readTriangle(Camellia_MeshDir+"NACA0012/NACA0012.1", bf, H1Order, pToAdd);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// solution->setFilter(pc);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(solution, mesh, varFactory);
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
solution->solve(false);
if (commRank == 0)
{
stringstream outfile;
if (highLiftAirfoil)
outfile << "highlift_" << refIndex;
else
outfile << "naca0012_" << refIndex;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_minus_sigma_n) );
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;
}
if (refIndex < numRefs)
{
// refinementStrategy.refine(commRank==0); // print to console on commRank 0
// Try pseudo-hp adaptive
vector<int> cellsToRefine;
vector<int> cells_h;
vector<int> cells_p;
refinementStrategy.getCellsAboveErrorThreshhold(cellsToRefine);
for (int i=0; i < cellsToRefine.size(); i++)
if (sqrt(mesh->getCellMeasure(cellsToRefine[i])) < epsilon)
{
int pOrder = mesh->cellPolyOrder(cellsToRefine[i]);
if (pOrder < 8)
cells_p.push_back(cellsToRefine[i]);
else
cells_h.push_back(cellsToRefine[i]);
}
else
cells_h.push_back(cellsToRefine[i]);
refinementStrategy.pRefineCells(mesh, cells_p);
refinementStrategy.hRefineCells(mesh, cells_h);
}
}
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 commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = coupled robust");
// Optional arguments (have defaults)
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation", false);
double Re = args.Input("--Re", "Reynolds number", 40);
double nu = 1./Re;
double lambda = Re/2.-sqrt(Re*Re/4+4*pi*pi);
int maxNewtonIterations = args.Input("--maxIterations", "maximum number of Newton iterations", 20);
int polyOrder = args.Input("--polyOrder", "polynomial order for field variables", 2);
int deltaP = args.Input("--deltaP", "how much to enrich test space", 2);
// string saveFile = args.Input<string>("--meshSaveFile", "file to which to save refinement history", "");
// string replayFile = args.Input<string>("--meshLoadFile", "file with refinement history to replay", "");
args.Process();
// if (commRank==0)
// {
// cout << "saveFile is " << saveFile << endl;
// cout << "loadFile is " << replayFile << endl;
// }
//////////////////// PROBLEM DEFINITIONS ///////////////////////
int H1Order = polyOrder+1;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
// VarPtr tau11 = varFactory.testVar("tau11", HGRAD);
// VarPtr tau12 = varFactory.testVar("tau12", HGRAD);
// VarPtr tau22 = varFactory.testVar("tau22", HGRAD);
VarPtr tau1 = varFactory.testVar("tau1", HDIV);
VarPtr tau2 = varFactory.testVar("tau2", HDIV);
VarPtr v1 = varFactory.testVar("v1", HGRAD);
VarPtr v2 = varFactory.testVar("v2", HGRAD);
VarPtr q = varFactory.testVar("q", HGRAD);
// define trial variables
VarPtr u1 = varFactory.fieldVar("u1");
VarPtr u2 = varFactory.fieldVar("u2");
// VarPtr sigma11 = varFactory.fieldVar("sigma11");
// VarPtr sigma12 = varFactory.fieldVar("sigma12");
// VarPtr sigma22 = varFactory.fieldVar("sigma22");
VarPtr sigma1 = varFactory.fieldVar("sigma1", VECTOR_L2);
VarPtr sigma2 = varFactory.fieldVar("sigma2", VECTOR_L2);
VarPtr u1hat = varFactory.traceVar("u1hat");
VarPtr u2hat = varFactory.traceVar("u2hat");
VarPtr t1hat = varFactory.fluxVar("t1hat");
VarPtr t2hat = varFactory.fluxVar("t2hat");
VarPtr p = varFactory.fieldVar("p");
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
double xmin = -0.5;
double xmax = 1.0;
double ymin = -0.5;
double ymax = 1.5;
meshBoundary(0,0) = xmin; // x1
meshBoundary(0,1) = ymin; // y1
meshBoundary(1,0) = xmax;
meshBoundary(1,1) = ymin;
meshBoundary(2,0) = xmax;
meshBoundary(2,1) = ymax;
meshBoundary(3,0) = xmin;
meshBoundary(3,1) = ymax;
int horizontalCells = 6, verticalCells = 8;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+deltaP);
////////////////////////////////////////////////////////////////////
// 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 u1_prev = Function::solution(u1, backgroundFlow);
FunctionPtr u2_prev = Function::solution(u2, backgroundFlow);
FunctionPtr sigma1_prev = Function::solution(sigma1, backgroundFlow);
FunctionPtr sigma2_prev = Function::solution(sigma2, backgroundFlow);
FunctionPtr p_prev = Function::solution(p, backgroundFlow);
// FunctionPtr sigma11_prev = Function::solution(sigma11, backgroundFlow);
// FunctionPtr sigma12_prev = Function::solution(sigma12, backgroundFlow);
// FunctionPtr sigma22_prev = Function::solution(sigma22, backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction(1.0) );
FunctionPtr u1Exact = Teuchos::rcp( new ExactU1(lambda) );
FunctionPtr u2Exact = Teuchos::rcp( new ExactU2(lambda) );
// FunctionPtr beta = e1 * u1_prev + e2 * u2_prev;
// ==================== SET INITIAL GUESS ==========================
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u1->ID()] = u1Exact;
functionMap[u2->ID()] = u2Exact;
// functionMap[sigma1->ID()] = Function::vectorize(zero,zero);
// functionMap[sigma2->ID()] = Function::vectorize(zero,zero);
// functionMap[p->ID()] = zero;
backgroundFlow->projectOntoMesh(functionMap);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
// // stress equation
bf->addTerm( 1./nu*sigma1, tau1 );
bf->addTerm( 1./nu*sigma2, tau2 );
bf->addTerm( u1, tau1->div() );
bf->addTerm( u2, tau2->div() );
bf->addTerm( -u1hat, tau1->dot_normal() );
bf->addTerm( -u2hat, tau2->dot_normal() );
// bf->addTerm( 1./(2*nu)*sigma11, tau11 );
// bf->addTerm( 1./(2*nu)*sigma12, tau12 );
// bf->addTerm( 1./(2*nu)*sigma12, tau12 );
// bf->addTerm( 1./(2*nu)*sigma22, tau22 );
// bf->addTerm( u1, tau11->dx() );
// bf->addTerm( u1, tau12->dy() );
// bf->addTerm( u2, tau12->dx() );
// bf->addTerm( u2, tau22->dy() );
// bf->addTerm( -u1hat, tau11->times_normal_x() );
// bf->addTerm( -u1hat, tau12->times_normal_y() );
// bf->addTerm( -u2hat, tau12->times_normal_x() );
// bf->addTerm( -u2hat, tau22->times_normal_y() );
// momentum equation
bf->addTerm( -2.*u1_prev*u1, v1->dx() );
bf->addTerm( -u2_prev*u1, v1->dy() );
bf->addTerm( -u1_prev*u2, v1->dy() );
bf->addTerm( -u2_prev*u1, v2->dx() );
bf->addTerm( -u1_prev*u2, v1->dy() );
bf->addTerm( -2.*u2_prev*u2, v2->dy() );
bf->addTerm( -p, v1->dx() );
bf->addTerm( -p, v2->dy() );
// bf->addTerm( sigma11, v1->dx() );
// bf->addTerm( sigma12, v1->dy() );
// bf->addTerm( sigma12, v2->dx() );
// bf->addTerm( sigma22, v2->dy() );
bf->addTerm( sigma1, v1->grad() );
bf->addTerm( sigma2, v2->grad() );
bf->addTerm( t1hat, v1);
bf->addTerm( t2hat, v2);
// continuity equation
bf->addTerm( -u1, q->dx() );
bf->addTerm( -u2, q->dy() );
bf->addTerm( u1hat, q->times_normal_x() );
bf->addTerm( u2hat, q->times_normal_y() );
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
// stress equation
rhs->addTerm( -u1_prev * tau1->div() );
rhs->addTerm( -u2_prev * tau2->div() );
// momentum equation
rhs->addTerm( 2.*u1_prev*u1_prev * v1->dx() );
rhs->addTerm( u2_prev*u1_prev * v1->dy() );
rhs->addTerm( u1_prev*u2_prev * v1->dy() );
rhs->addTerm( u2_prev*u1_prev * v2->dx() );
rhs->addTerm( u1_prev*u2_prev * v1->dy() );
rhs->addTerm( 2.*u2_prev*u2_prev * v2->dy() );
// rhs->addTerm( p_prev * v1->dx() );
// rhs->addTerm( p_prev * v2->dy() );
// rhs->addTerm( -sigma1_prev * v1->grad() );
// rhs->addTerm( -sigma2_prev * v2->grad() );
// rhs->addTerm( -sigma11_prev * v1->dx() );
// rhs->addTerm( -sigma12_prev * v1->dy() );
// rhs->addTerm( -sigma12_prev * v2->dx() );
// rhs->addTerm( -sigma22_prev * v2->dy() );
// continuity equation
rhs->addTerm( u1_prev * q->dx() );
rhs->addTerm( u2_prev * q->dy() );
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (norm == 0)
{
ip = bf->graphNorm();
}
else if (norm == 1)
{
// ip = bf->l2Norm();
}
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
SpatialFilterPtr left = Teuchos::rcp( new ConstantXBoundary(-0.5) );
SpatialFilterPtr right = Teuchos::rcp( new ConstantXBoundary(1) );
SpatialFilterPtr top = Teuchos::rcp( new ConstantYBoundary(-0.5) );
SpatialFilterPtr bottom = Teuchos::rcp( new ConstantYBoundary(1.5) );
bc->addDirichlet(u1hat, left, u1Exact);
bc->addDirichlet(u2hat, left, u2Exact);
bc->addDirichlet(u1hat, right, u1Exact);
bc->addDirichlet(u2hat, right, u2Exact);
bc->addDirichlet(u1hat, top, u1Exact);
bc->addDirichlet(u2hat, top, u2Exact);
bc->addDirichlet(u1hat, bottom, u1Exact);
bc->addDirichlet(u2hat, bottom, u2Exact);
// zero mean constraint on pressure
bc->addZeroMeanConstraint(p);
// pc->addConstraint(u1hat*u2hat-t1hat == zero, top);
// pc->addConstraint(u2hat*u2hat-t2hat == zero, top);
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// solution->setFilter(pc);
// if (enforceLocalConservation) {
// solution->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y() == zero);
// }
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(backgroundFlow);
// Teuchos::RCP< RefinementHistory > refHistory = Teuchos::rcp( new RefinementHistory );
// mesh->registerObserver(refHistory);
//////////////////// SOLVE & REFINE ///////////////////////
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(backgroundFlow, mesh, varFactory);
stringstream outfile;
outfile << "kovasznay" << "_" << 0;
exporter.exportSolution(outfile.str());
double nonlinearRelativeEnergyTolerance = 1e-5; // used to determine convergence of the nonlinear solution
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
double L2Update = 1e10;
int iterCount = 0;
while (L2Update > nonlinearRelativeEnergyTolerance && iterCount < maxNewtonIterations)
{
solution->solve(false);
double u1L2Update = solution->L2NormOfSolutionGlobal(u1->ID());
double u2L2Update = solution->L2NormOfSolutionGlobal(u2->ID());
L2Update = sqrt(u1L2Update*u1L2Update + u2L2Update*u2L2Update);
// Check local conservation
if (commRank == 0)
{
cout << "L2 Norm of Update = " << L2Update << endl;
// if (saveFile.length() > 0) {
// std::ostringstream oss;
// oss << string(saveFile) << refIndex ;
// cout << "on refinement " << refIndex << " saving mesh file to " << oss.str() << endl;
// refHistory->saveToFile(oss.str());
// }
}
// line search algorithm
double alpha = 1.0;
backgroundFlow->addSolution(solution, alpha);
iterCount++;
}
if (commRank == 0)
{
stringstream outfile;
outfile << "kovasznay" << "_" << refIndex+1;
exporter.exportSolution(outfile.str());
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
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);
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 ENABLE_INTEL_FLOATING_POINT_EXCEPTIONS
cout << "NOTE: enabling floating point exceptions for divide by zero.\n";
_MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~_MM_MASK_INVALID);
#endif
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int rank = Teuchos::GlobalMPISession::getRank();
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
//cout << "rank: " << rank << " of " << numProcs << endl;
#else
Epetra_SerialComm Comm;
#endif
Comm.Barrier(); // set breakpoint here to allow debugger attachment to other MPI processes than the one you automatically attached to.
Teuchos::CommandLineProcessor cmdp(false,true); // false: don't throw exceptions; true: do return errors for unrecognized options
double minTol = 1e-8;
bool use3D = false;
int refCount = 10;
int k = 4; // poly order for field variables
int delta_k = use3D ? 3 : 2; // test space enrichment
int k_coarse = 0;
bool useMumps = true;
bool useGMGSolver = true;
bool enforceOneIrregularity = true;
bool useStaticCondensation = false;
bool conformingTraces = false;
bool useDiagonalScaling = false; // of the global stiffness matrix in GMGSolver
bool printRefinementDetails = false;
bool useWeightedGraphNorm = true; // graph norm scaled according to units, more or less
int numCells = 2;
int AztecOutputLevel = 1;
int gmgMaxIterations = 10000;
int smootherOverlap = 0;
double relativeTol = 1e-6;
double D = 1.0; // characteristic length scale
cmdp.setOption("polyOrder",&k,"polynomial order for field variable u");
cmdp.setOption("delta_k", &delta_k, "test space polynomial order enrichment");
cmdp.setOption("k_coarse", &k_coarse, "polynomial order for field variables on coarse mesh");
cmdp.setOption("numRefs",&refCount,"number of refinements");
cmdp.setOption("D", &D, "domain dimension");
cmdp.setOption("useConformingTraces", "useNonConformingTraces", &conformingTraces);
cmdp.setOption("enforceOneIrregularity", "dontEnforceOneIrregularity", &enforceOneIrregularity);
cmdp.setOption("smootherOverlap", &smootherOverlap, "overlap for smoother");
cmdp.setOption("printRefinementDetails", "dontPrintRefinementDetails", &printRefinementDetails);
cmdp.setOption("azOutput", &AztecOutputLevel, "Aztec output level");
cmdp.setOption("numCells", &numCells, "number of cells in the initial mesh");
cmdp.setOption("useScaledGraphNorm", "dontUseScaledGraphNorm", &useWeightedGraphNorm);
// cmdp.setOption("gmgTol", &gmgTolerance, "tolerance for GMG convergence");
cmdp.setOption("relativeTol", &relativeTol, "Energy error-relative tolerance for iterative solver.");
cmdp.setOption("gmgMaxIterations", &gmgMaxIterations, "tolerance for GMG convergence");
bool enhanceUField = false;
cmdp.setOption("enhanceUField", "dontEnhanceUField", &enhanceUField);
cmdp.setOption("useStaticCondensation", "dontUseStaticCondensation", &useStaticCondensation);
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
double width = D, height = D, depth = D;
VarFactory varFactory;
// fields:
VarPtr u = varFactory.fieldVar("u", L2);
VarPtr sigma = varFactory.fieldVar("\\sigma", VECTOR_L2);
FunctionPtr n = Function::normal();
// traces:
VarPtr u_hat;
if (conformingTraces)
{
u_hat = varFactory.traceVar("\\widehat{u}", u);
}
else
{
cout << "Note: using non-conforming traces.\n";
u_hat = varFactory.traceVar("\\widehat{u}", u, L2);
}
VarPtr sigma_n_hat = varFactory.fluxVar("\\widehat{\\sigma}_{n}", sigma * n);
// test functions:
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
BFPtr poissonBF = Teuchos::rcp( new BF(varFactory) );
FunctionPtr alpha = Function::constant(1); // viscosity
// tau terms:
poissonBF->addTerm(sigma / alpha, tau);
poissonBF->addTerm(-u, tau->div()); // (sigma1, tau1)
poissonBF->addTerm(u_hat, tau * n);
// v terms:
poissonBF->addTerm(- sigma, v->grad()); // (mu sigma1, grad v1)
poissonBF->addTerm( sigma_n_hat, v);
int horizontalCells = numCells, verticalCells = numCells, depthCells = numCells;
vector<double> domainDimensions;
domainDimensions.push_back(width);
domainDimensions.push_back(height);
vector<int> elementCounts;
elementCounts.push_back(horizontalCells);
elementCounts.push_back(verticalCells);
if (use3D)
{
domainDimensions.push_back(depth);
elementCounts.push_back(depthCells);
}
MeshPtr mesh, k0Mesh;
int H1Order = k + 1;
int H1Order_coarse = k_coarse + 1;
if (!use3D)
{
Teuchos::ParameterList pl;
map<int,int> trialOrderEnhancements;
if (enhanceUField)
{
trialOrderEnhancements[u->ID()] = 1;
}
BFPtr poissonBilinearForm = poissonBF;
pl.set("useMinRule", true);
pl.set("bf",poissonBilinearForm);
pl.set("H1Order", H1Order);
pl.set("delta_k", delta_k);
pl.set("horizontalElements", horizontalCells);
pl.set("verticalElements", verticalCells);
pl.set("divideIntoTriangles", false);
pl.set("useConformingTraces", conformingTraces);
pl.set("trialOrderEnhancements", &trialOrderEnhancements);
pl.set("x0",(double)0);
pl.set("y0",(double)0);
pl.set("width", width);
pl.set("height",height);
mesh = MeshFactory::quadMesh(pl);
pl.set("H1Order", H1Order_coarse);
k0Mesh = MeshFactory::quadMesh(pl);
}
else
{
mesh = MeshFactory::rectilinearMesh(poissonBF, domainDimensions, elementCounts, H1Order, delta_k);
k0Mesh = MeshFactory::rectilinearMesh(poissonBF, domainDimensions, elementCounts, H1Order_coarse, delta_k);
}
mesh->registerObserver(k0Mesh); // ensure that the k0 mesh refinements track those of the solution mesh
RHSPtr rhs = RHS::rhs(); // zero
FunctionPtr sin_pi_x = Teuchos::rcp( new Sin_ax(PI/D) );
FunctionPtr sin_pi_y = Teuchos::rcp( new Sin_ay(PI/D) );
FunctionPtr u_exact = sin_pi_x * sin_pi_y;
FunctionPtr f = -(2.0 * PI * PI / (D * D)) * sin_pi_x * sin_pi_y;
rhs->addTerm( f * v );
BCPtr bc = BC::bc();
SpatialFilterPtr boundary = SpatialFilter::allSpace();
bc->addDirichlet(u_hat, boundary, u_exact);
IPPtr graphNorm;
FunctionPtr h = Teuchos::rcp( new hFunction() );
if (useWeightedGraphNorm)
{
graphNorm = IP::ip();
graphNorm->addTerm( tau->div() ); // u
graphNorm->addTerm( (h / alpha) * tau - h * v->grad() ); // sigma
graphNorm->addTerm( v ); // boundary term (adjoint to u)
graphNorm->addTerm( h * tau );
// // new effort, with the idea that the test norm should be considered in reference space, basically
// graphNorm = IP::ip();
// graphNorm->addTerm( tau->div() ); // u
// graphNorm->addTerm( tau / h - v->grad() ); // sigma
// graphNorm->addTerm( v / h ); // boundary term (adjoint to u)
// graphNorm->addTerm( tau / h );
}
else
{
map<int, double> trialWeights; // on the squared terms in the trial space norm
trialWeights[u->ID()] = 1.0 / (D * D);
trialWeights[sigma->ID()] = 1.0;
graphNorm = poissonBF->graphNorm(trialWeights, 1.0); // 1.0: weight on the L^2 terms
}
SolutionPtr solution = Solution::solution(mesh, bc, rhs, graphNorm);
solution->setUseCondensedSolve(useStaticCondensation);
mesh->registerSolution(solution); // sign up for projection of old solution onto refined cells.
double energyThreshold = 0.2;
RefinementStrategy refinementStrategy( solution, energyThreshold );
refinementStrategy.setReportPerCellErrors(true);
refinementStrategy.setEnforceOneIrregularity(enforceOneIrregularity);
Teuchos::RCP<Solver> coarseSolver, fineSolver;
if (useMumps)
{
#ifdef HAVE_AMESOS_MUMPS
coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#else
cout << "useMumps=true, but MUMPS is not available!\n";
exit(0);
#endif
}
else
{
coarseSolver = Teuchos::rcp( new KluSolver );
}
GMGSolver* gmgSolver;
if (useGMGSolver)
{
double tol = relativeTol;
int maxIters = gmgMaxIterations;
BCPtr zeroBCs = bc->copyImposingZero();
gmgSolver = new GMGSolver(zeroBCs, k0Mesh, graphNorm, mesh, solution->getDofInterpreter(),
solution->getPartitionMap(), maxIters, tol, coarseSolver,
useStaticCondensation);
gmgSolver->setAztecOutput(AztecOutputLevel);
gmgSolver->setUseConjugateGradient(true);
gmgSolver->gmgOperator()->setSmootherType(GMGOperator::IFPACK_ADDITIVE_SCHWARZ);
gmgSolver->gmgOperator()->setSmootherOverlap(smootherOverlap);
fineSolver = Teuchos::rcp( gmgSolver );
}
else
{
fineSolver = coarseSolver;
}
// if (rank==0) cout << "experimentally starting by solving with MUMPS on the fine mesh.\n";
// solution->solve( Teuchos::rcp( new MumpsSolver) );
solution->solve(fineSolver);
#ifdef HAVE_EPETRAEXT_HDF5
ostringstream dir_name;
dir_name << "poissonCavityFlow_k" << k;
HDF5Exporter exporter(mesh,dir_name.str());
exporter.exportSolution(solution,varFactory,0);
#endif
#ifdef HAVE_AMESOS_MUMPS
if (useMumps) coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#endif
solution->reportTimings();
if (useGMGSolver) gmgSolver->gmgOperator()->reportTimings();
for (int refIndex=0; refIndex < refCount; refIndex++)
{
double energyError = solution->energyErrorTotal();
GlobalIndexType numFluxDofs = mesh->numFluxDofs();
if (rank==0)
{
cout << "Before refinement " << refIndex << ", energy error = " << energyError;
cout << " (using " << numFluxDofs << " trace degrees of freedom)." << endl;
}
bool printToConsole = printRefinementDetails && (rank==0);
refinementStrategy.refine(printToConsole);
if (useStaticCondensation)
{
CondensedDofInterpreter* condensedDofInterpreter = dynamic_cast<CondensedDofInterpreter*>(solution->getDofInterpreter().get());
if (condensedDofInterpreter != NULL)
{
condensedDofInterpreter->reinitialize();
}
}
GlobalIndexType fineDofs = mesh->globalDofCount();
GlobalIndexType coarseDofs = k0Mesh->globalDofCount();
if (rank==0)
{
cout << "After refinement, coarse mesh has " << k0Mesh->numActiveElements() << " elements and " << coarseDofs << " dofs.\n";
cout << " Fine mesh has " << mesh->numActiveElements() << " elements and " << fineDofs << " dofs.\n";
}
if (!use3D)
{
ostringstream fineMeshLocation, coarseMeshLocation;
fineMeshLocation << "poissonFineMesh_k" << k << "_ref" << refIndex;
GnuPlotUtil::writeComputationalMeshSkeleton(fineMeshLocation.str(), mesh, true); // true: label cells
coarseMeshLocation << "poissonCoarseMesh_k" << k << "_ref" << refIndex;
GnuPlotUtil::writeComputationalMeshSkeleton(coarseMeshLocation.str(), k0Mesh, true); // true: label cells
}
if (useGMGSolver) // create fresh fineSolver now that the meshes have changed:
{
#ifdef HAVE_AMESOS_MUMPS
if (useMumps) coarseSolver = Teuchos::rcp( new MumpsSolver(512, true) );
#endif
double tol = max(relativeTol * energyError, minTol);
int maxIters = gmgMaxIterations;
BCPtr zeroBCs = bc->copyImposingZero();
gmgSolver = new GMGSolver(zeroBCs, k0Mesh, graphNorm, mesh, solution->getDofInterpreter(),
solution->getPartitionMap(), maxIters, tol, coarseSolver, useStaticCondensation);
gmgSolver->setAztecOutput(AztecOutputLevel);
gmgSolver->setUseDiagonalScaling(useDiagonalScaling);
fineSolver = Teuchos::rcp( gmgSolver );
}
solution->solve(fineSolver);
solution->reportTimings();
if (useGMGSolver) gmgSolver->gmgOperator()->reportTimings();
#ifdef HAVE_EPETRAEXT_HDF5
exporter.exportSolution(solution,varFactory,refIndex+1);
#endif
}
double energyErrorTotal = solution->energyErrorTotal();
GlobalIndexType numFluxDofs = mesh->numFluxDofs();
GlobalIndexType numGlobalDofs = mesh->numGlobalDofs();
if (rank==0)
{
cout << "Final mesh has " << mesh->numActiveElements() << " elements and " << numFluxDofs << " trace dofs (";
cout << numGlobalDofs << " total dofs, including fields).\n";
cout << "Final energy error: " << energyErrorTotal << endl;
}
#ifdef HAVE_EPETRAEXT_HDF5
exporter.exportSolution(solution,varFactory,0);
#endif
if (!use3D)
{
GnuPlotUtil::writeComputationalMeshSkeleton("poissonRefinedMesh", mesh, true);
}
coarseSolver = Teuchos::rcp((Solver*) NULL); // without this when useMumps = true and running on one rank, we see a crash on exit, which may have to do with MPI being finalized before coarseSolver is deleted.
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 commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
double epsilon = args.Input<double>("--epsilon", "diffusion parameter");
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
int norm = args.Input<int>("--norm", "0 = graph\n 1 = robust\n 2 = modified robust");
// Optional arguments (have defaults)
bool zeroL2 = args.Input("--zeroL2", "take L2 term on v in robust norm to zero", true);
args.Process();
//////////////////// 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("uhat");
VarPtr fhat = varFactory.fluxVar("fhat");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma = varFactory.fieldVar("sigma", VECTOR_L2);
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
int H1Order = 3, pToAdd = 2;
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = 0.0; // x1
meshBoundary(0,1) = 0.0; // y1
meshBoundary(1,0) = 1.0;
meshBoundary(1,1) = 0.0;
meshBoundary(2,0) = 1.0;
meshBoundary(2,1) = 1.0;
meshBoundary(3,0) = 0.0;
meshBoundary(3,1) = 1.0;
int horizontalCells = 4, verticalCells = 4;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+pToAdd, false);
vector<double> beta;
beta.push_back(2.0);
beta.push_back(1.0);
//////////////////// DEFINE BILINEAR FORM ///////////////////////
// tau terms:
bf->addTerm(sigma / epsilon, tau);
bf->addTerm(u, tau->div());
bf->addTerm(-uhat, tau->dot_normal());
// v terms:
bf->addTerm( sigma, v->grad() );
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( fhat, v);
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = Teuchos::rcp(new IP);
if (norm == 0)
{
ip = bf->graphNorm();
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
ip->addZeroMeanTerm( h2_scaling*v );
}
// Robust norm
else if (norm == 1)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
// Weight these two terms for inflow
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
// Modified robust norm
else if (norm == 2)
{
// robust test norm
FunctionPtr ip_scaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
FunctionPtr h2_scaling = Teuchos::rcp( new ZeroMeanScaling );
// FunctionPtr ip_weight = Teuchos::rcp( new IPWeight() );
if (!zeroL2)
ip->addTerm( v );
ip->addTerm( sqrt(epsilon) * v->grad() );
ip->addTerm( beta * v->grad() );
ip->addTerm( tau->div() - beta*v->grad() );
ip->addTerm( ip_scaling/sqrt(epsilon) * tau );
if (zeroL2)
ip->addZeroMeanTerm( h2_scaling*v );
}
//////////////////// SPECIFY RHS ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
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 InflowBoundary );
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new OutflowBoundary );
FunctionPtr u0 = Teuchos::rcp( new U0 );
bc->addDirichlet(uhat, outflowBoundary, u0);
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
bc->addDirichlet(fhat, inflowBoundary, beta*n*u0);
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp(new PenaltyConstraints);
// pc->addConstraint(uhat==u0,inflowBoundary);
//////////////////// SOLVE & REFINE ///////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// solution->setFilter(pc);
if (enforceLocalConservation) {
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(fhat == zero);
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(solution, mesh, varFactory);
ofstream errOut;
if (commRank == 0)
errOut.open("confusion_err.txt");
for (int refIndex=0; refIndex<=numRefs; refIndex++){
solution->solve(false);
double energy_error = solution->energyErrorTotal();
if (commRank==0){
stringstream outfile;
outfile << "confusion_" << refIndex;
exporter.exportSolution(outfile.str());
// solution->writeToVTK(outfile.str());
// Check local conservation
FunctionPtr flux = Function::solution(fhat, solution);
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;
errOut << mesh->numGlobalDofs() << " " << energy_error << " "
<< fluxImbalances[0] << " " << fluxImbalances[1] << " " << fluxImbalances[2] << endl;
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
if (commRank == 0)
errOut.close();
return 0;
}
