void PoissonExactSolution::setUseSinglePointBCForPHI(bool useSinglePointBCForPhi, IndexType vertexIndexForZeroValue)
{
FunctionPtr phi_exact = phi();
VarFactoryPtr vf = _bf->varFactory();
VarPtr psi_hat_n = vf->fluxVar(PoissonBilinearForm::S_PSI_HAT_N);
VarPtr q = vf->testVar(PoissonBilinearForm::S_Q, HGRAD);
VarPtr phi = vf->fieldVar(PoissonBilinearForm::S_PHI);
SpatialFilterPtr wholeBoundary = SpatialFilter::allSpace();
FunctionPtr n = Function::normal();
FunctionPtr psi_n_exact = phi_exact->grad() * n;
_bc = BC::bc();
_bc->addDirichlet(psi_hat_n, wholeBoundary, psi_n_exact);
if (!useSinglePointBCForPhi)
{
_bc->addZeroMeanConstraint(phi);
}
else
{
std::vector<double> point = getPointForBCImposition();
double value = Function::evaluate(phi_exact, point[0], point[1]);
// cout << "PoissonExactSolution: imposing phi = " << value << " at (" << point[0] << ", " << point[1] << ")\n";
_bc->addSpatialPointBC(phi->ID(), value, point);
}
}
map<int, FunctionPtr > PreviousSolutionFunction::functionMap( vector< VarPtr > varPtrs, SolutionPtr soln) {
map<int, FunctionPtr > functionMap;
for (vector< VarPtr >::iterator varIt = varPtrs.begin(); varIt != varPtrs.end(); varIt++) {
VarPtr var = *varIt;
functionMap[var->ID()] = Teuchos::rcp( new PreviousSolutionFunction(soln, var));
}
return functionMap;
}
BFPtr TestBilinearFormDx::bf()
{
VarFactoryPtr vf = VarFactory::varFactory();
VarPtr u = vf->fieldVar("u",HGRAD);
VarPtr v = vf->testVar("v",HGRAD);
BFPtr bf = BF::bf(vf);
bf->addTerm(u->dx(), v->dx());
return bf;
}
bool LinearTermTests::testLinearTermEvaluation()
{
bool success = true;
double eps = .1;
FunctionPtr one = Function::constant(1.0);
vector<double> e1,e2;
e1.push_back(1.0);
e1.push_back(0.0);
e2.push_back(0.0);
e2.push_back(1.0);
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define a couple LinearTerms
LinearTermPtr vVecLT = Teuchos::rcp(new LinearTerm);
LinearTermPtr tauVecLT = Teuchos::rcp(new LinearTerm);
vVecLT->addTerm(sqrt(eps)*v->grad());
tauVecLT->addTerm((1/sqrt(eps))*tau);
//////////////////// evaluate LinearTerms /////////////////
map<int,FunctionPtr> errRepMap;
errRepMap[v->ID()] = one;
errRepMap[tau->ID()] = one*e1+one*e2; // vector valued fxn (1,1)
FunctionPtr errTau = tauVecLT->evaluate(errRepMap,false);
FunctionPtr errV = vVecLT->evaluate(errRepMap,false);
try
{
bool xTauZero = errTau->x()->isZero();
bool yTauZero = errTau->y()->isZero();
bool xVZero = errV->dx()->isZero();
bool yVZero = errV->dy()->isZero();
}
catch (...)
{
cout << "testLinearTermEvaluation: Caught exception.\n";
success = false;
}
/*
FunctionPtr xErr = (errTau->x())*(errTau->x()) + (errV->dx())*(errV->dx());
FunctionPtr yErr = (errTau->y())*(errTau->y()) + (errV->dy())*(errV->dy());
double xErrVal = xErr->integrate(mesh,15,true);
*/
// if we don't crash, return success
return success;
}
void writePatchValues(double xMin, double xMax, double yMin, double yMax,
SolutionPtr solution, VarPtr u1, string filename,
int numPoints=100)
{
FieldContainer<double> points = pointGrid(xMin,xMax,yMin,yMax,numPoints);
FieldContainer<double> values(numPoints*numPoints);
solution->solutionValues(values, u1->ID(), points);
ofstream fout(filename.c_str());
fout << setprecision(15);
fout << "X = zeros(" << numPoints << ",1);\n";
// fout << "Y = zeros(numPoints);\n";
fout << "U = zeros(" << numPoints << "," << numPoints << ");\n";
for (int i=0; i<numPoints; i++)
{
fout << "X(" << i+1 << ")=" << points(i,0) << ";\n";
}
for (int i=0; i<numPoints; i++)
{
fout << "Y(" << i+1 << ")=" << points(i,1) << ";\n";
}
for (int i=0; i<numPoints; i++)
{
for (int j=0; j<numPoints; j++)
{
int pointIndex = i*numPoints + j;
fout << "U("<<i+1<<","<<j+1<<")=" << values(pointIndex) << ";" << endl;
}
}
fout.close();
}
PreviousSolutionFunction::PreviousSolutionFunction(SolutionPtr soln, VarPtr var, bool multiplyFluxesByCellParity) : Function(var->rank()) {
_soln = soln;
_solnExpression = 1.0 * var;
_overrideMeshCheck = false;
if ((var->varType() == FLUX) && multiplyFluxesByCellParity) {
FunctionPtr parity = Teuchos::rcp( new SideParityFunction );
_solnExpression = parity * var;
}
}
double integralOverMesh(LinearTermPtr testTerm, VarPtr testVar, FunctionPtr fxnToSubstitute) {
map<int, FunctionPtr > varAsFunction;
varAsFunction[testVar->ID()] = fxnToSubstitute;
FunctionPtr substituteOnBoundary = testTerm->evaluate(varAsFunction, true);
FunctionPtr substituteOnInterior = testTerm->evaluate(varAsFunction, false);
double integral = substituteOnBoundary->integrate(mesh);
integral += substituteOnInterior->integrate(mesh);
return integral;
}
void VarItemDelegate::drawBar (VarPtr dt, QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const {
(void)index;
// QItemDelegate::drawBackground(painter,option,index);
if (dt!=0) {
if (dt->getType() != VARTYPE_ID_BOOL && dt->hasValue() && dt->hasMinValue() && dt->hasMaxValue()) {
painter->save();
QRectF rect=option.rect;
double border_x=2.0;
double width=rect.width()-(border_x*2.0);
if (width < 0.0) width=0.0;
rect.setX(rect.x()+border_x);
rect.setWidth(width);
double range=dt->getMaxValue() - dt->getMinValue();
double value=dt->getValue()-dt->getMinValue();
double pos=0.0;
if (range!=0.0) pos=(value/range)*width;
if (pos < 0.0) pos=0.0;
if (pos > width) pos=width;
QRectF bar=rect;
double height=2;
bar.setY(bar.y()+(bar.height() - (height + 1)));
bar.setHeight(height);
QRectF frame=bar;
bar.setWidth(pos);
QColor high_c;
if (option.state & QStyle::State_Selected) {
high_c=option.palette.color(QPalette::HighlightedText);
} else {
high_c=option.palette.color(QPalette::Highlight);
}
high_c.setAlpha(96);
//painter->setPen(QPen(high_c,1));
//painter->setBrush(Qt::NoBrush);
painter->setPen(Qt::NoPen);
painter->setBrush(QBrush(high_c));
painter->drawRect(frame);
high_c.setAlpha(192);
QColor nocolor(255,255,255,0) ;
painter->setPen(Qt::NoPen);
painter->setBrush(QBrush(high_c));
painter->drawRect(bar);
painter->restore();
}
}
}
PreviousSolutionFunction<Scalar>::PreviousSolutionFunction(TSolutionPtr<Scalar> soln, VarPtr var, bool multiplyFluxesByCellParity) : TFunction<Scalar>(var->rank())
{
_soln = soln;
_solnExpression = 1.0 * var;
_overrideMeshCheck = false;
if ((var->varType() == FLUX) && multiplyFluxesByCellParity)
{
TFunctionPtr<double> parity = TFunction<double>::sideParity();
_solnExpression = parity * var;
}
}
FieldContainer<double> solutionData(FieldContainer<double> &points, SolutionPtr solution, VarPtr u1) {
int numPoints = points.dimension(0);
FieldContainer<double> values(numPoints);
solution->solutionValues(values, u1->ID(), points);
FieldContainer<double> xyzData(numPoints, 3);
for (int ptIndex=0; ptIndex<numPoints; ptIndex++) {
xyzData(ptIndex,0) = points(ptIndex,0);
xyzData(ptIndex,1) = points(ptIndex,1);
xyzData(ptIndex,2) = values(ptIndex);
}
return xyzData;
}
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;
}
void MainWindow::notificationExample(VarPtr node) {
printf("Value of node '%s' was changed to: '%s'\n",node->getName().c_str(),node->getString().c_str());
}
bool LinearTermTests::testIntegrateMixedBasis()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u_hat = varFactory->fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory->fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(1.0);
//////////////////// DEFINE BILINEAR FORM/Mesh ///////////////////////
BFPtr convectionBF = Teuchos::rcp( new BF(varFactory) );
// v terms:
convectionBF->addTerm( -u, beta * v->grad() );
convectionBF->addTerm( beta_n_u_hat, v);
convectionBF->addTerm( u, v);
// build CONSTANT SINGLE ELEMENT MESH
int order = 0;
int H1Order = order+1;
int pToAdd = 1;
int nCells = 2; // along a side
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells,convectionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = mesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, mesh));
vector<GlobalIndexType> cellIDs;
vector< ElementPtr > allElems = mesh->activeElements();
vector< ElementPtr >::iterator elemIt;
for (elemIt=allElems.begin(); elemIt!=allElems.end(); elemIt++)
{
cellIDs.push_back((*elemIt)->cellID());
}
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(mesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
int numTrialDofs = elemType->trialOrderPtr->totalDofs();
int numCells = mesh->numActiveElements();
double areaPerCell = 1.0 / numCells;
FieldContainer<double> integrals(numCells,numTrialDofs);
FieldContainer<double> expectedIntegrals(numCells,numTrialDofs);
double sidelengthOfCell = 1.0 / nCells;
DofOrderingPtr trialOrdering = elemType->trialOrderPtr;
int dofForField = trialOrdering->getDofIndex(u->ID(), 0);
vector<int> dofsForFlux;
const vector<int>* sidesForFlux = &trialOrdering->getSidesForVarID(beta_n_u_hat->ID());
for (vector<int>::const_iterator sideIt = sidesForFlux->begin(); sideIt != sidesForFlux->end(); sideIt++)
{
int sideIndex = *sideIt;
dofsForFlux.push_back(trialOrdering->getDofIndex(beta_n_u_hat->ID(), 0, sideIndex));
}
for (int cellIndex = 0; cellIndex < numCells; cellIndex++)
{
expectedIntegrals(cellIndex, dofForField) = areaPerCell;
for (vector<int>::iterator dofIt = dofsForFlux.begin(); dofIt != dofsForFlux.end(); dofIt++)
{
int fluxDofIndex = *dofIt;
expectedIntegrals(cellIndex, fluxDofIndex) = sidelengthOfCell;
}
}
// cout << "expectedIntegrals:\n" << expectedIntegrals;
// setup: with constant degrees of freedom, we expect that the integral of int_dK (flux) + int_K (field) will be ones for each degree of freedom, assuming the basis functions for these constants field/flux variables are just C = 1.0.
//
//On a unit square, int_K (constant) = 1.0, and int_dK (u_i) = 1, for i = 0,...,3.
LinearTermPtr lt = 1.0 * beta_n_u_hat;
LinearTermPtr field = 1.0 * u;
lt->addTerm(field,true);
lt->integrate(integrals, elemType->trialOrderPtr, basisCache);
double tol = 1e-12;
double maxDiff;
success = TestSuite::fcsAgree(integrals,expectedIntegrals,tol,maxDiff);
if (success==false)
{
cout << "Failed testIntegrateMixedBasis with maxDiff = " << maxDiff << endl;
}
return success;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int 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 numSteps = args.Input<int>("--numSteps", "num NR steps",20);
int polyOrder = 0;
// define our manufactured solution or problem bilinear form:
bool useTriangles = false;
int pToAdd = 1;
args.Process();
int H1Order = polyOrder + 1;
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// new-style bilinear form definition
VarFactory varFactory;
VarPtr fn = varFactory.fluxVar("\\widehat{\\beta_n_u}");
VarPtr u = varFactory.fieldVar("u");
VarPtr v = varFactory.testVar("v",HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) ); // initialize bilinear form
////////////////////////////////////////////////////////////////////
// CREATE MESH
////////////////////////////////////////////////////////////////////
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = MeshUtilities::buildUnitQuadMesh(nCells , bf, H1Order, H1Order+pToAdd);
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL); RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL); IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
SolutionPtr solnPerturbation = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
vector<double> e1(2),e2(2);
e1[0] = 1; e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// v:
bf->addTerm( -u, beta * v->grad());
bf->addTerm( fn, v);
////////////////////////////////////////////////////////////////////
// DEFINE RHS
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr u_prev_squared_div2 = 0.5 * u_prev * u_prev;
rhs->addTerm((e1 * u_prev_squared_div2 + e2 * u_prev) * v->grad());
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
FunctionPtr zero = Function::constant(0.0);
FunctionPtr u0 = Teuchos::rcp( new U0 );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
// FunctionPtr parity = Teuchos::rcp(new SideParityFunction);
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u0;
// functionMap[fn->ID()] = -(e1 * u0_squared_div_2 + e2 * u0) * n * parity;
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm( v );
ip->addTerm(v->grad());
// ip->addTerm( beta * v->grad() ); // omitting term to make IP non-dependent on u
////////////////////////////////////////////////////////////////////
// DEFINE DIRICHLET BC
////////////////////////////////////////////////////////////////////
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new TopBoundary);
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(outflowBoundary) );
Teuchos::RCP<BCEasy> inflowBC = Teuchos::rcp( new BCEasy );
inflowBC->addDirichlet(fn,inflowBoundary,
( e1 * u0_squared_div_2 + e2 * u0) * n );
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution); solution->setCubatureEnrichmentDegree(10);
////////////////////////////////////////////////////////////////////
// HESSIAN BIT + CHECKS ON GRADIENT + HESSIAN
////////////////////////////////////////////////////////////////////
VarFactory hessianVars = varFactory.getBubnovFactory(VarFactory::BUBNOV_TRIAL);
VarPtr du = hessianVars.test(u->ID());
// BFPtr hessianBF = Teuchos::rcp( new BF(hessianVars) ); // initialize bilinear form
FunctionPtr du_current = Teuchos::rcp( new PreviousSolutionFunction(solution, u) );
FunctionPtr fnhat = Teuchos::rcp(new PreviousSolutionFunction(solution,fn));
LinearTermPtr residual = Teuchos::rcp(new LinearTerm);// residual
residual->addTerm(fnhat*v,true);
residual->addTerm( - (e1 * (u_prev_squared_div2) + e2 * (u_prev)) * v->grad(),true);
LinearTermPtr Bdu = Teuchos::rcp(new LinearTerm);// residual
Bdu->addTerm( - du_current*(beta*v->grad()));
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(mesh, ip, residual));
Teuchos::RCP<RieszRep> duRiesz = Teuchos::rcp(new RieszRep(mesh, ip, Bdu));
riesz->computeRieszRep();
FunctionPtr e_v = Teuchos::rcp(new RepFunction(v,riesz));
e_v->writeValuesToMATLABFile(mesh, "e_v.m");
FunctionPtr posErrPart = Teuchos::rcp(new PositivePart(e_v->dx()));
// hessianBF->addTerm(e_v->dx()*u,du);
// hessianBF->addTerm(posErrPart*u,du);
// Teuchos::RCP<NullFilter> nullFilter = Teuchos::rcp(new NullFilter);
// Teuchos::RCP<HessianFilter> hessianFilter = Teuchos::rcp(new HessianFilter(hessianBF));
Teuchos::RCP< LineSearchStep > LS_Step = Teuchos::rcp(new LineSearchStep(riesz));
double NL_residual = 9e99;
for (int i = 0;i<numSteps;i++){
// write matrix to file and then resollve without hessian
/*
solution->setFilter(hessianFilter);
stringstream oss;
oss << "hessianMatrix" << i << ".dat";
solution->setWriteMatrixToFile(true,oss.str());
solution->solve(false);
solution->setFilter(nullFilter);
oss.str(""); // clear
oss << "stiffnessMatrix" << i << ".dat";
solution->setWriteMatrixToFile(false,oss.str());
*/
solution->solve(false); // do one solve to initialize things...
double stepLength = 1.0;
stepLength = LS_Step->stepSize(backgroundFlow,solution, NL_residual);
// solution->setWriteMatrixToFile(true,"stiffness.dat");
backgroundFlow->addSolution(solution,stepLength);
NL_residual = LS_Step->getNLResidual();
if (rank==0){
cout << "NL residual after adding = " << NL_residual << " with step size " << stepLength << endl;
}
double fd_gradient;
for (int dofIndex = 0;dofIndex<mesh->numGlobalDofs();dofIndex++){
TestingUtilities::initializeSolnCoeffs(solnPerturbation);
TestingUtilities::setSolnCoeffForGlobalDofIndex(solnPerturbation,1.0,dofIndex);
fd_gradient = FiniteDifferenceUtilities::finiteDifferenceGradient(mesh, riesz, backgroundFlow, dofIndex);
// CHECK GRADIENT
LinearTermPtr b_u = bf->testFunctional(solnPerturbation);
map<int,FunctionPtr> NL_err_rep_map;
NL_err_rep_map[v->ID()] = Teuchos::rcp(new RepFunction(v,riesz));
FunctionPtr gradient = b_u->evaluate(NL_err_rep_map, TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)); // use boundary part only if flux or trace
double grad;
if (TestingUtilities::isFluxOrTraceDof(mesh,dofIndex)){
grad = gradient->integralOfJump(mesh,10);
}else{
grad = gradient->integrate(mesh,10);
}
double fdgrad = fd_gradient;
double diff = grad-fdgrad;
if (abs(diff)>1e-6 && i>0){
cout << "Found difference of " << diff << ", " << " with fd val = " << fdgrad << " and gradient = " << grad << " in dof " << dofIndex << ", isTraceDof = " << TestingUtilities::isFluxOrTraceDof(mesh,dofIndex) << endl;
}
}
}
VTKExporter exporter(solution, mesh, varFactory);
if (rank==0){
exporter.exportSolution("qopt");
cout << endl;
}
return 0;
}
void TransientTests::SetUp()
{
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
beta_n_u_hat = varFactory.fluxVar("\\widehat{\\beta \\cdot n }");
u = varFactory.fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// BUILD MESH ///////////////////////
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 = 4, verticalCells = 4;
// create a pointer to a new mesh:
mesh = MeshFactory::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);
prevTimeFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
flowResidual = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
FunctionPtr u_prev_time = Teuchos::rcp( new PreviousSolutionFunction(prevTimeFlow, u) );
//////////////////// DEFINE BILINEAR FORM ///////////////////////
RHSPtr rhs = RHS::rhs();
FunctionPtr invDt = Teuchos::rcp(new ScalarParamFunction(1.0/dt));
// v terms:
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_hat, v);
// transient terms
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();
//////////////////// CREATE BCs ///////////////////////
BCPtr bc = BC::bc();
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
FunctionPtr u1 = Teuchos::rcp( new InletBC );
bc->addDirichlet(beta_n_u_hat, lBoundary, -u1);
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 ConstantScalarFunction(u_free) );
// prevTimeFlow->projectOntoMesh(functionMap);
}
int main(int argc, char *argv[])
{
// Process command line arguments
#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 v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u_hat = varFactory.fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory.fieldVar("u");
FunctionPtr beta = Teuchos::rcp(new Beta());
//////////////////// BUILD MESH ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = -1.0; // x1
meshBoundary(0,1) = -1.0; // y1
meshBoundary(1,0) = 1.0;
meshBoundary(1,1) = -1.0;
meshBoundary(2,0) = 1.0;
meshBoundary(2,1) = 1.0;
meshBoundary(3,0) = -1.0;
meshBoundary(3,1) = 1.0;
int horizontalCells = 32, verticalCells = 32;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
confusionBF, 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:
confusionBF->addTerm( beta * u, - v->grad() );
confusionBF->addTerm( beta_n_u_hat, v);
confusionBF->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) ///////////////////////
// robust test norm
IPPtr ip = confusionBF->graphNorm();
// IPPtr ip = Teuchos::rcp(new IP);
// ip->addTerm(v);
// ip->addTerm(invDt*v - beta*v->grad());
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new InflowSquareBoundary(beta) );
FunctionPtr u0 = Teuchos::rcp( new ConstantScalarFunction(0) );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
bc->addDirichlet(beta_n_u_hat, inflowBoundary, beta*n*u0);
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 ==========================
FunctionPtr u_init = Teuchos::rcp(new InitialCondition());
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u_init;
prevTimeFlow->projectOntoMesh(functionMap);
//////////////////// SOLVE & REFINE ///////////////////////
// if (enforceLocalConservation) {
// // 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_minus_sigma_n) );
// LinearTermPtr sourcePart = Teuchos::rcp<LinearTerm>( new LinearTerm(invDt, u) );
// conservedQuantity->addTerm(sourcePart, true);
// solution->lagrangeConstraints()->addConstraint(conservedQuantity == u_prev_time * invDt);
// }
int timestepCount = 0;
double time_tol = 1e-8;
double L2_time_residual = 1e9;
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 (rank == 0)
{
cout << endl << "Timestep: " << timestepCount << ", dt = " << dt << ", Time residual = " << L2_time_residual << endl;
stringstream outfile;
outfile << "rotatingCylinder_" << timestepCount;
solution->writeToVTK(outfile.str(), 5);
// 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++;
}
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);
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;
}
bool LinearTermTests::testRieszInversionAsProjection()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 2;
int pToAdd = 2;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 2;
int horizontalCells = nCells, verticalCells = nCells;
// create a new mesh:
MeshPtr myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells, confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh));
vector<GlobalIndexType> cellIDs = myMesh->cellIDsOfTypeGlobal(elemType);
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(myMesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
LinearTermPtr integrand = Teuchos::rcp(new LinearTerm); // residual
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
FunctionPtr testFxn1 = x;
FunctionPtr testFxn2 = y;
FunctionPtr fxnToProject = x * y + 1.0;
integrand->addTerm(fxnToProject * v);
IPPtr ip_L2 = Teuchos::rcp(new IP);
ip_L2->addTerm(v);
ip_L2->addTerm(tau);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, ip_L2, integrand));
riesz->computeRieszRep();
FunctionPtr rieszFxn = RieszRep::repFunction(v,riesz);
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numPts = basisCache->getPhysicalCubaturePoints().dimension(1);
FieldContainer<double> valProject( numCells, numPts );
FieldContainer<double> valExpected( numCells, numPts );
rieszFxn->values(valProject,basisCache);
fxnToProject->values(valExpected,basisCache);
// int rank = Teuchos::GlobalMPISession::getRank();
// if (rank==0) cout << "physicalCubaturePoints:\n" << basisCache->getPhysicalCubaturePoints();
double maxDiff;
double tol = 1e-12;
success = TestSuite::fcsAgree(valProject,valExpected,tol,maxDiff);
if (success==false)
{
cout << "Failed Riesz Inversion Projection test with maxDiff = " << maxDiff << endl;
serializeOutput("valExpected", valExpected);
serializeOutput("valProject", valProject);
serializeOutput("physicalPoints", basisCache->getPhysicalCubaturePoints());
}
return allSuccess(success);
}
// tests Riesz inversion by integration by parts
bool LinearTermTests::testRieszInversion()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 1;
int pToAdd = 1;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 1;
int horizontalCells = nCells, verticalCells = nCells;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh));
vector<GlobalIndexType> cellIDs;
vector<ElementPtr> elems = myMesh->activeElements();
vector<ElementPtr>::iterator elemIt;
for (elemIt=elems.begin(); elemIt!=elems.end(); elemIt++)
{
int cellID = (*elemIt)->cellID();
cellIDs.push_back(cellID);
}
bool createSideCacheToo = true;
basisCache->setPhysicalCellNodes(myMesh->physicalCellNodesGlobal(elemType), cellIDs, createSideCacheToo);
LinearTermPtr integrand = Teuchos::rcp(new LinearTerm);// residual
LinearTermPtr integrandIBP = Teuchos::rcp(new LinearTerm);// residual
vector<double> e1(2); // (1,0)
vector<double> e2(2); // (0,1)
e1[0] = 1;
e2[1] = 1;
FunctionPtr n = Function::normal();
FunctionPtr X = Function::xn(1);
FunctionPtr Y = Function::yn(1);
FunctionPtr testFxn1 = X;
FunctionPtr testFxn2 = Y;
FunctionPtr divTestFxn = testFxn1->dx() + testFxn2->dy();
FunctionPtr vectorTest = testFxn1*e1 + testFxn2*e2;
integrand->addTerm(divTestFxn*v);
integrandIBP->addTerm(vectorTest*n*v - vectorTest*v->grad()); // boundary term
IPPtr sobolevIP = Teuchos::rcp(new IP);
sobolevIP->addTerm(v);
sobolevIP->addTerm(tau);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, sobolevIP, integrand));
// riesz->setPrintOption(true);
riesz->computeRieszRep();
Teuchos::RCP<RieszRep> rieszIBP = Teuchos::rcp(new RieszRep(myMesh, sobolevIP, integrandIBP));
riesz->setFunctional(integrandIBP);
// rieszIBP->setPrintOption(true);
rieszIBP->computeRieszRep();
FunctionPtr rieszOrigFxn = RieszRep::repFunction(v,riesz);
FunctionPtr rieszIBPFxn = RieszRep::repFunction(v,rieszIBP);
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numPts = basisCache->getPhysicalCubaturePoints().dimension(1);
FieldContainer<double> valOriginal( numCells, numPts);
FieldContainer<double> valIBP( numCells, numPts);
rieszOrigFxn->values(valOriginal,basisCache);
rieszIBPFxn->values(valIBP,basisCache);
double maxDiff;
double tol = 1e-14;
success = TestSuite::fcsAgree(valOriginal,valIBP,tol,maxDiff);
if (success==false)
{
cout << "Failed TestRieszInversion with maxDiff = " << maxDiff << endl;
}
return success;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
int rank=mpiSession.getRank();
int numProcs=mpiSession.getNProc();
#else
int rank = 0;
int numProcs = 1;
#endif
int polyOrder = 3;
int pToAdd = 2; // for tests
// define our manufactured solution or problem bilinear form:
double epsilon = 1e-2;
bool useTriangles = false;
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 H1Order = polyOrder + 1;
int horizontalCells = 1, verticalCells = 1;
double energyThreshold = 0.2; // for mesh refinements
double nonlinearStepSize = 0.5;
double nonlinearRelativeEnergyTolerance = 0.015; // used to determine convergence of the nonlinear solution
////////////////////////////////////////////////////////////////////
// SET UP PROBLEM
////////////////////////////////////////////////////////////////////
Teuchos::RCP<BurgersBilinearForm> oldBurgersBF = Teuchos::rcp(new BurgersBilinearForm(epsilon));
// new-style bilinear form definition
VarFactory varFactory;
VarPtr uhat = varFactory.traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_hat = varFactory.fluxVar("\\widehat{\\beta_n u - \\sigma_n}");
VarPtr u = varFactory.fieldVar("u");
VarPtr sigma1 = varFactory.fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory.fieldVar("\\sigma_2");
VarPtr tau = varFactory.testVar("\\tau",HDIV);
VarPtr v = varFactory.testVar("v",HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(quadPoints, horizontalCells, verticalCells, bf, H1Order, H1Order+pToAdd, useTriangles);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
Teuchos::RCP<Solution> backgroundFlow = Teuchos::rcp(new Solution(mesh, Teuchos::rcp((BC*)NULL) , Teuchos::rcp((RHS*)NULL), Teuchos::rcp((DPGInnerProduct*)NULL))); // create null solution
oldBurgersBF->setBackgroundFlow(backgroundFlow);
// tau parts:
// 1/eps (sigma, tau)_K + (u, div tau)_K - (u_hat, tau_n)_dK
bf->addTerm(sigma1 / epsilon, tau->x());
bf->addTerm(sigma2 / epsilon, tau->y());
bf->addTerm(u, tau->div());
bf->addTerm( - uhat, tau->dot_normal() );
vector<double> e1(2); // (1,0)
e1[0] = 1;
vector<double> e2(2); // (0,1)
e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
// v:
// (sigma, grad v)_K - (sigma_hat_n, v)_dK - (u, beta dot grad v) + (u_hat * n dot beta, v)_dK
bf->addTerm( sigma1, v->dx() );
bf->addTerm( sigma2, v->dy() );
bf->addTerm( -u, beta * v->grad());
bf->addTerm( beta_n_u_minus_sigma_hat, v);
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
map<int, Teuchos::RCP<AbstractFunction> > functionMap;
functionMap[BurgersBilinearForm::U] = Teuchos::rcp(new InitialGuess());
functionMap[BurgersBilinearForm::SIGMA_1] = Teuchos::rcp(new ZeroFunction());
functionMap[BurgersBilinearForm::SIGMA_2] = Teuchos::rcp(new ZeroFunction());
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
// compare stiffness matrices for first linear step:
int trialOrder = 1;
pToAdd = 0;
int testOrder = trialOrder + pToAdd;
CellTopoPtr quadTopoPtr = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ));
DofOrderingFactory dofOrderingFactory(bf);
DofOrderingPtr testOrdering = dofOrderingFactory.testOrdering(testOrder, *quadTopoPtr);
DofOrderingPtr trialOrdering = dofOrderingFactory.trialOrdering(trialOrder, *quadTopoPtr);
int numCells = 1;
// just use testOrdering for both trial and test spaces (we only use to define BasisCache)
ElementTypePtr elemType = Teuchos::rcp( new ElementType(trialOrdering, testOrdering, quadTopoPtr) );
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType) );
quadPoints.resize(1,quadPoints.dimension(0),quadPoints.dimension(1));
basisCache->setPhysicalCellNodes(quadPoints,vector<int>(1),true); // true: do create side cache
FieldContainer<double> cellSideParities(numCells,quadTopoPtr->getSideCount());
cellSideParities.initialize(1.0); // not worried here about neighbors actually having opposite parity -- just want the two BF implementations to agree...
FieldContainer<double> expectedValues(numCells, testOrdering->totalDofs(), trialOrdering->totalDofs() );
FieldContainer<double> actualValues(numCells, testOrdering->totalDofs(), trialOrdering->totalDofs() );
oldBurgersBF->stiffnessMatrix(expectedValues, elemType, cellSideParities, basisCache);
bf->stiffnessMatrix(actualValues, elemType, cellSideParities, basisCache);
// compare beta's as well
FieldContainer<double> expectedBeta = oldBurgersBF->getBeta(basisCache);
Teuchos::Array<int> dim;
expectedBeta.dimensions(dim);
FieldContainer<double> actualBeta(dim);
beta->values(actualBeta,basisCache);
double tol = 1e-14;
double maxDiff;
if (rank == 0)
{
if ( ! TestSuite::fcsAgree(expectedBeta,actualBeta,tol,maxDiff) )
{
cout << "Test failed: old Burgers beta differs from new; maxDiff " << maxDiff << ".\n";
cout << "Old beta: \n" << expectedBeta;
cout << "New beta: \n" << actualBeta;
}
else
{
cout << "Old and new Burgers beta agree!!\n";
}
if ( ! TestSuite::fcsAgree(expectedValues,actualValues,tol,maxDiff) )
{
cout << "Test failed: old Burgers stiffness differs from new; maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New: \n" << actualValues;
cout << "TrialDofOrdering: \n" << *trialOrdering;
cout << "TestDofOrdering:\n" << *testOrdering;
}
else
{
cout << "Old and new Burgers stiffness agree!!\n";
}
}
// define our inner product:
// Teuchos::RCP<BurgersInnerProduct> ip = Teuchos::rcp( new BurgersInnerProduct( bf, mesh ) );
// function to scale the squared guy by epsilon/h
FunctionPtr epsilonOverHScaling = Teuchos::rcp( new EpsilonScaling(epsilon) );
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm(tau);
ip->addTerm(tau->div());
ip->addTerm( epsilonOverHScaling * v );
ip->addTerm( sqrt(sqrt(epsilon)) * v->grad() );
ip->addTerm( beta * v->grad() );
// use old IP instead, for now...
Teuchos::RCP<BurgersInnerProduct> oldIP = Teuchos::rcp( new BurgersInnerProduct( oldBurgersBF, mesh ) );
expectedValues.resize(numCells, testOrdering->totalDofs(), testOrdering->totalDofs() );
actualValues.resize (numCells, testOrdering->totalDofs(), testOrdering->totalDofs() );
BasisCachePtr ipBasisCache = Teuchos::rcp( new BasisCache(elemType, true) ); // true: test vs. test
ipBasisCache->setPhysicalCellNodes(quadPoints,vector<int>(1),false); // false: don't create side cache
oldIP->computeInnerProductMatrix(expectedValues,testOrdering,ipBasisCache);
ip->computeInnerProductMatrix(actualValues,testOrdering,ipBasisCache);
tol = 1e-14;
maxDiff = 0.0;
if (rank==0)
{
if ( ! TestSuite::fcsAgree(expectedValues,actualValues,tol,maxDiff) )
{
cout << "Test failed: old inner product differs from new IP; maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New IP: \n" << actualValues;
cout << "testOrdering: \n" << *testOrdering;
}
else
{
cout << "Old inner product and new IP agree!!\n";
}
}
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
// the RHS as implemented by BurgersProblem divides the first component of beta by 2.0
// so we follow that. I've not done the math; just imitating the code...
Teuchos::RCP<RHSEasy> otherRHS = Teuchos::rcp( new RHSEasy );
vector<double> e1_div2 = e1;
e1_div2[0] /= 2.0;
FunctionPtr rhsBeta = (e1_div2 * beta * e1 + Teuchos::rcp( new ConstantVectorFunction( e2 ) )) * u_prev;
otherRHS->addTerm( rhsBeta * v->grad() - u_prev * tau->div() );
Teuchos::RCP<BurgersProblem> problem = Teuchos::rcp( new BurgersProblem(oldBurgersBF) );
expectedValues.resize(numCells, testOrdering->totalDofs() );
actualValues.resize (numCells, testOrdering->totalDofs() );
problem->integrateAgainstStandardBasis(expectedValues,testOrdering,basisCache);
otherRHS->integrateAgainstStandardBasis(actualValues,testOrdering,basisCache);
tol = 1e-14;
maxDiff = 0.0;
if (rank==0)
{
if ( ! TestSuite::fcsAgree(expectedValues,actualValues,tol,maxDiff) )
{
cout << "Test failed: old RHS differs from new (\"otherRHS\"); maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New: \n" << actualValues;
cout << "testOrdering: \n" << *testOrdering;
}
else
{
cout << "Old and new RHS (\"otherRHS\") agree!!\n";
}
}
FunctionPtr u_prev_squared_div2 = 0.5 * u_prev * u_prev;
rhs->addTerm( (e1 * u_prev_squared_div2 + e2 * u_prev) * v->grad() - u_prev * tau->div());
if (! functionsAgree(e2 * u_prev,
Teuchos::rcp( new ConstantVectorFunction( e2 ) ) * u_prev,
basisCache) )
{
cout << "two like functions differ...\n";
}
FunctionPtr e1_f = Teuchos::rcp( new ConstantVectorFunction( e1 ) );
FunctionPtr e2_f = Teuchos::rcp( new ConstantVectorFunction( e2 ) );
FunctionPtr one = Teuchos::rcp( new ConstantScalarFunction( 1.0 ) );
if (! functionsAgree( Teuchos::rcp( new ProductFunction(e1_f, (e1_f + e2_f)) ), // e1_f * (e1_f + e2_f)
one,
basisCache) )
{
cout << "two like functions differ...\n";
}
if (! functionsAgree(u_prev_squared_div2,
(e1_div2 * beta) * u_prev,
basisCache) )
{
cout << "two like functions differ...\n";
}
if (! functionsAgree(e1 * u_prev_squared_div2,
(e1_div2 * beta * e1) * u_prev,
basisCache) )
{
cout << "two like functions differ...\n";
}
if (! functionsAgree(e1 * u_prev_squared_div2 + e2 * u_prev,
(e1_div2 * beta * e1 + Teuchos::rcp( new ConstantVectorFunction( e2 ) )) * u_prev,
basisCache) )
{
cout << "two like functions differ...\n";
}
problem->integrateAgainstStandardBasis(expectedValues,testOrdering,basisCache);
rhs->integrateAgainstStandardBasis(actualValues,testOrdering,basisCache);
tol = 1e-14;
maxDiff = 0.0;
if (rank==0)
{
if ( ! TestSuite::fcsAgree(expectedValues,actualValues,tol,maxDiff) )
{
cout << "Test failed: old RHS differs from new (\"rhs\"); maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New: \n" << actualValues;
cout << "testOrdering: \n" << *testOrdering;
}
else
{
cout << "Old and new RHS (\"rhs\") agree!!\n";
}
}
SpatialFilterPtr outflowBoundary = Teuchos::rcp( new TopBoundary );
SpatialFilterPtr inflowBoundary = Teuchos::rcp( new NegatedSpatialFilter(outflowBoundary) );
Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp(new PenaltyConstraints);
LinearTermPtr sigma_hat = beta * uhat->times_normal() - beta_n_u_minus_sigma_hat;
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
pc->addConstraint(sigma_hat==zero,outflowBoundary);
FunctionPtr u0 = Teuchos::rcp( new U0 );
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
Teuchos::RCP<BCEasy> inflowBC = Teuchos::rcp( new BCEasy );
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
inflowBC->addDirichlet(beta_n_u_minus_sigma_hat,inflowBoundary, ( e1 * u0_squared_div_2 + e2 * u0) * n );
// create a solution object
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution);
solution->setFilter(pc);
// old penalty filter:
Teuchos::RCP<LocalStiffnessMatrixFilter> penaltyBC = Teuchos::rcp(new PenaltyMethodFilter(problem));
// solution->setFilter(penaltyBC);
// compare old and new filters
elemType = mesh->getElement(0)->elementType();
trialOrdering = elemType->trialOrderPtr;
testOrdering = elemType->testOrderPtr;
// stiffness
expectedValues.resize(numCells, trialOrdering->totalDofs(), trialOrdering->totalDofs() );
actualValues.resize (numCells, trialOrdering->totalDofs(), trialOrdering->totalDofs() );
expectedValues.initialize(0.0);
actualValues.initialize(0.0);
// load
FieldContainer<double> expectedLoad(numCells, trialOrdering->totalDofs() );
FieldContainer<double> actualLoad(numCells, trialOrdering->totalDofs() );
penaltyBC->filter(expectedValues,expectedLoad,basisCache,mesh,problem);
pc->filter(actualValues,actualLoad,basisCache,mesh,problem);
maxDiff = 0.0;
if (rank==0)
{
if ( ! TestSuite::fcsAgree(expectedValues,actualValues,tol,maxDiff) )
{
cout << "Test failed: old penalty stiffness differs from new; maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New: \n" << actualValues;
cout << "trialOrdering: \n" << *trialOrdering;
}
else
{
cout << "Old and new penalty stiffness agree!!\n";
}
}
if (rank==0)
{
if ( ! TestSuite::fcsAgree(expectedLoad,actualLoad,tol,maxDiff) )
{
cout << "Test failed: old penalty load differs from new; maxDiff " << maxDiff << ".\n";
cout << "Old: \n" << expectedValues;
cout << "New: \n" << actualValues;
cout << "trialOrdering: \n" << *trialOrdering;
}
else
{
cout << "Old and new penalty load agree!!\n";
}
}
// define refinement strategy:
Teuchos::RCP<RefinementStrategy> refinementStrategy = Teuchos::rcp(new RefinementStrategy(solution,energyThreshold));
// =================== END INITIALIZATION CODE ==========================
// refine the spectral mesh, for comparability with the original Burgers' driver
mesh->hRefine(vector<int>(1),RefinementPattern::regularRefinementPatternQuad());
int numRefs = 5;
Teuchos::RCP<NonlinearStepSize> stepSize = Teuchos::rcp(new NonlinearStepSize(nonlinearStepSize));
Teuchos::RCP<NonlinearSolveStrategy> solveStrategy = Teuchos::rcp(
new NonlinearSolveStrategy(backgroundFlow, solution, stepSize, nonlinearRelativeEnergyTolerance)
);
for (int refIndex=0; refIndex<numRefs; refIndex++)
{
solveStrategy->solve(rank==0);
refinementStrategy->refine(rank==0); // print to console on rank 0
}
// one more nonlinear solve on refined mesh
int numNRSteps = 5;
for (int i=0; i<numNRSteps; i++)
{
solution->solve(false);
backgroundFlow->addSolution(solution,1.0);
}
if (rank==0)
{
backgroundFlow->writeFieldsToFile(BurgersBilinearForm::U, "u_ref.m");
backgroundFlow->writeFieldsToFile(BurgersBilinearForm::SIGMA_1, "sigmax.m");
backgroundFlow->writeFieldsToFile(BurgersBilinearForm::SIGMA_2, "sigmay.m");
solution->writeFluxesToFile(BurgersBilinearForm::U_HAT, "du_hat_ref.dat");
}
return 0;
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv, 0);
int spaceDim = 2;
int meshWidth = 2;
bool conformingTraces = true;
int H1Order = 2, delta_k = 3;
double domainWidth = 1.0e-3;
bool diagScaling = false;
double h = domainWidth / meshWidth;
double weight = h / 4.0; // ratio of area of square with sidelength h to its perimeter
double sigma_weight = 1.0; // h / 4.0; // sigma = sigma_weight * u->grad()
Space uHatSpace = conformingTraces ? HGRAD : L2;
VarFactoryPtr vf = VarFactory::varFactory();
// fields
VarPtr u = vf->fieldVar("u");
VarPtr sigma = vf->fieldVar("sigma", VECTOR_L2);
// traces
VarPtr u_hat = vf->traceVar("u_hat", uHatSpace);
VarPtr sigma_n = vf->fluxVar("sigma_n");
// tests
VarPtr v = vf->testVar("v", HGRAD);
VarPtr tau = vf->testVar("tau", HDIV);
BFPtr bf = BF::bf(vf);
// standard BF:
// bf->addTerm(sigma, v->grad());
// bf->addTerm(sigma_n, v);
//
// bf->addTerm(sigma, tau);
// bf->addTerm(u, tau->div());
// bf->addTerm(-u_hat, tau->dot_normal());
// weighted BF:
bf->addTerm(sigma, v->grad());
bf->addTerm(weight * sigma_n, v);
bf->addTerm(sigma, tau);
bf->addTerm(sigma_weight * u, tau->div());
bf->addTerm(- sigma_weight * weight * u_hat, tau->dot_normal());
IPPtr ip = IP::ip();
// standard IP:
ip->addTerm(tau + v->grad());
ip->addTerm(tau->div());
ip->addTerm(v);
ip->addTerm(tau);
// weighted IP:
// ip->addTerm(tau + v->grad());
// ip->addTerm(sigma_weight * tau->div());
// ip->addTerm(max(sigma_weight,1e-3) * v);
// ip->addTerm(sigma_weight * weight * tau);
BCPtr bc = BC::bc();
bc->addDirichlet(u_hat, SpatialFilter::allSpace(), Function::zero());
RHSPtr rhs = RHS::rhs();
rhs->addTerm(1.0 * sigma_weight * v);
vector<double> dimensions(spaceDim,domainWidth);
vector<int> elementCounts(spaceDim,meshWidth);
MeshPtr mesh = MeshFactory::rectilinearMesh(bf, dimensions, elementCounts, H1Order, delta_k);
SolutionPtr soln = Solution::solution(mesh, bc, rhs, ip);
soln->setUseCondensedSolve(true);
soln->initializeLHSVector();
soln->initializeStiffnessAndLoad();
soln->populateStiffnessAndLoad();
Teuchos::RCP<Epetra_RowMatrix> stiffness = soln->getStiffnessMatrix();
double condNumber = conditionNumberLAPACK(*stiffness, diagScaling);
cout << "condest (1-norm): " << condNumber << endl;
return 0;
}
int main(int argc, char *argv[]) {
// Process command line arguments
if (argc > 1)
numRefs = atof(argv[1]);
#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
FunctionPtr beta = Teuchos::rcp(new Beta());
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// test variables
VarFactory varFactory;
VarPtr tau = varFactory.testVar("\\tau", HDIV);
VarPtr v = varFactory.testVar("v", HGRAD);
// 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");
////////////////////////////////////////////////////////////////////
// CREATE MESH
////////////////////////////////////////////////////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
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 = 4, verticalCells = 4;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd, false);
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND 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) );
// ==================== SET INITIAL GUESS ==========================
double u_free = 0.0;
double sigma1_free = 0.0;
double sigma2_free = 0.0;
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = Teuchos::rcp( new ConstantScalarFunction(u_free) );
functionMap[sigma1->ID()] = Teuchos::rcp( new ConstantScalarFunction(sigma1_free) );
functionMap[sigma2->ID()] = Teuchos::rcp( new ConstantScalarFunction(sigma2_free) );
prevTimeFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// tau terms:
confusionBF->addTerm(sigma1 / epsilon, tau->x());
confusionBF->addTerm(sigma2 / epsilon, 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 * u, - v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
////////////////////////////////////////////////////////////////////
// TIMESTEPPING TERMS
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
double dt = 0.25;
FunctionPtr invDt = Teuchos::rcp(new ScalarParamFunction(1.0/dt));
if (rank==0){
cout << "Timestep dt = " << dt << endl;
}
if (transient)
{
confusionBF->addTerm( u, invDt*v );
rhs->addTerm( u_prev_time * invDt * v );
}
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
// 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 / epsilon + 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(epsilon) );
if (!enforceLocalConservation)
{
robIP->addTerm( ip_scaling * v );
if (transient)
robIP->addTerm( invDt * 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 );
////////////////////////////////////////////////////////////////////
// DEFINE RHS
////////////////////////////////////////////////////////////////////
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
////////////////////////////////////////////////////////////////////
// DEFINE BC
////////////////////////////////////////////////////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
// Teuchos::RCP<PenaltyConstraints> pc = Teuchos::rcp( new PenaltyConstraints );
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
SpatialFilterPtr tbBoundary = Teuchos::rcp( new TopBottomBoundary );
SpatialFilterPtr rBoundary = Teuchos::rcp( new RightBoundary );
FunctionPtr u0 = Teuchos::rcp( new ZeroBC );
FunctionPtr u_inlet = Teuchos::rcp( new InletBC );
// FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
bc->addDirichlet(beta_n_u_minus_sigma_n, lBoundary, u_inlet);
bc->addDirichlet(beta_n_u_minus_sigma_n, tbBoundary, u0);
bc->addDirichlet(uhat, rBoundary, u0);
// pc->addConstraint(beta_n_u_minus_sigma_n - uhat == u0, rBoundary);
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, robIP) );
// solution->setFilter(pc);
// ==================== Enforce Local Conservation ==================
if (enforceLocalConservation) {
if (transient)
{
FunctionPtr conserved_rhs = u_prev_time * invDt;
LinearTermPtr conserved_quantity = invDt * u;
LinearTermPtr flux_part = Teuchos::rcp(new LinearTerm(-1.0, beta_n_u_minus_sigma_n));
conserved_quantity->addTerm(flux_part, true);
// conserved_quantity = conserved_quantity - beta_n_u_minus_sigma_n;
solution->lagrangeConstraints()->addConstraint(conserved_quantity == conserved_rhs);
}
else
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_minus_sigma_n == zero);
}
}
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(prevTimeFlow); // u_t(i-1)
mesh->registerSolution(flowResidual); // u_t(i-1)
double energyThreshold = 0.25; // for mesh refinements
Teuchos::RCP<RefinementStrategy> refinementStrategy;
refinementStrategy = Teuchos::rcp(new RefinementStrategy(solution,energyThreshold));
////////////////////////////////////////////////////////////////////
// PSEUDO-TIME SOLVE STRATEGY
////////////////////////////////////////////////////////////////////
double time_tol = 1e-8;
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
double L2_time_residual = 1e7;
int timestepCount = 0;
if (!transient)
numTimeSteps = 1;
while((L2_time_residual > time_tol) && (timestepCount < numTimeSteps))
{
solution->solve(false);
// subtract solutions to get residual
flowResidual->setSolution(solution); // reset previous time solution to current time sol
flowResidual->addSolution(prevTimeFlow, -1.0);
double L2u = flowResidual->L2NormOfSolutionGlobal(u->ID());
double L2sigma1 = flowResidual->L2NormOfSolutionGlobal(sigma1->ID());
double L2sigma2 = flowResidual->L2NormOfSolutionGlobal(sigma2->ID());
L2_time_residual = sqrt(L2u*L2u + L2sigma1*L2sigma1 + L2sigma2*L2sigma2);
cout << endl << "Timestep: " << timestepCount << ", dt = " << dt << ", Time residual = " << L2_time_residual << endl;
if (rank == 0)
{
stringstream outfile;
if (transient)
outfile << "TransientConfusion_" << refIndex << "_" << timestepCount;
else
outfile << "TransientConfusion_" << refIndex;
solution->writeToVTK(outfile.str(), 5);
}
//////////////////////////////////////////////////////////////////////////
// Check conservation by testing against one
//////////////////////////////////////////////////////////////////////////
VarPtr testOne = varFactory.testVar("1", CONSTANT_SCALAR);
// Create a fake bilinear form for the testing
BFPtr fakeBF = Teuchos::rcp( new BF(varFactory) );
// Define our mass flux
FunctionPtr flux_current_time = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_minus_sigma_n) );
FunctionPtr delta_u = Teuchos::rcp( new PreviousSolutionFunction(flowResidual, u) );
LinearTermPtr surfaceFlux = -1.0 * flux_current_time * testOne;
LinearTermPtr volumeChange = invDt * delta_u * testOne;
LinearTermPtr massFluxTerm;
if (transient)
{
massFluxTerm = volumeChange;
// massFluxTerm->addTerm(surfaceFlux);
}
else
{
massFluxTerm = surfaceFlux;
}
// cout << "surface case = " << surfaceFlux->summands()[0].first->boundaryValueOnly() << " volume case = " << volumeChange->summands()[0].first->boundaryValueOnly() << endl;
// FunctionPtr massFlux= Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_minus_sigma_n) );
// LinearTermPtr massFluxTerm = massFlux * testOne;
Teuchos::RCP<shards::CellTopology> quadTopoPtr = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ));
DofOrderingFactory dofOrderingFactory(fakeBF);
int fakeTestOrder = H1Order;
DofOrderingPtr testOrdering = dofOrderingFactory.testOrdering(fakeTestOrder, *quadTopoPtr);
int testOneIndex = testOrdering->getDofIndex(testOne->ID(),0);
vector< ElementTypePtr > elemTypes = mesh->elementTypes(); // global element types
map<int, double> massFluxIntegral; // cellID -> integral
double maxMassFluxIntegral = 0.0;
double totalMassFlux = 0.0;
double totalAbsMassFlux = 0.0;
for (vector< ElementTypePtr >::iterator elemTypeIt = elemTypes.begin(); elemTypeIt != elemTypes.end(); elemTypeIt++)
{
ElementTypePtr elemType = *elemTypeIt;
vector< ElementPtr > elems = mesh->elementsOfTypeGlobal(elemType);
vector<int> cellIDs;
for (int i=0; i<elems.size(); i++) {
cellIDs.push_back(elems[i]->cellID());
}
FieldContainer<double> physicalCellNodes = mesh->physicalCellNodesGlobal(elemType);
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType,mesh) );
basisCache->setPhysicalCellNodes(physicalCellNodes,cellIDs,true); // true: create side caches
FieldContainer<double> cellMeasures = basisCache->getCellMeasures();
FieldContainer<double> fakeRHSIntegrals(elems.size(),testOrdering->totalDofs());
massFluxTerm->integrate(fakeRHSIntegrals,testOrdering,basisCache,true); // true: force side evaluation
for (int i=0; i<elems.size(); i++) {
int cellID = cellIDs[i];
// pick out the ones for testOne:
massFluxIntegral[cellID] = fakeRHSIntegrals(i,testOneIndex);
}
// find the largest:
for (int i=0; i<elems.size(); i++) {
int cellID = cellIDs[i];
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
}
for (int i=0; i<elems.size(); i++) {
int cellID = cellIDs[i];
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
totalMassFlux += massFluxIntegral[cellID];
totalAbsMassFlux += abs( massFluxIntegral[cellID] );
}
}
// Print results from processor with rank 0
if (rank == 0)
{
cout << "largest mass flux: " << maxMassFluxIntegral << endl;
cout << "total mass flux: " << totalMassFlux << endl;
cout << "sum of mass flux absolute value: " << totalAbsMassFlux << endl;
}
prevTimeFlow->setSolution(solution); // reset previous time solution to current time sol
timestepCount++;
}
if (refIndex < numRefs){
if (rank==0){
cout << "Performing refinement number " << refIndex << endl;
}
refinementStrategy->refine(rank==0);
// RESET solution every refinement - make sure discretization error doesn't creep in
// prevTimeFlow->projectOntoMesh(functionMap);
}
}
return 0;
}
void Projector::projectFunctionOntoBasis(FieldContainer<double> &basisCoefficients, FunctionPtr fxn,
BasisPtr basis, BasisCachePtr basisCache, IPPtr ip, VarPtr v,
set<int> fieldIndicesToSkip) {
CellTopoPtr cellTopo = basis->domainTopology();
DofOrderingPtr dofOrderPtr = Teuchos::rcp(new DofOrdering());
if (! fxn.get()) {
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "fxn cannot be null!");
}
int cardinality = basis->getCardinality();
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numDofs = cardinality - fieldIndicesToSkip.size();
if (numDofs==0) {
// we're skipping all the fields, so just initialize basisCoefficients to 0 and return
basisCoefficients.resize(numCells,cardinality);
basisCoefficients.initialize(0);
return;
}
FieldContainer<double> gramMatrix(numCells,cardinality,cardinality);
FieldContainer<double> ipVector(numCells,cardinality);
// fake a DofOrdering
DofOrderingPtr dofOrdering = Teuchos::rcp( new DofOrdering );
if (! basisCache->isSideCache()) {
dofOrdering->addEntry(v->ID(), basis, v->rank());
} else {
dofOrdering->addEntry(v->ID(), basis, v->rank(), basisCache->getSideIndex());
}
ip->computeInnerProductMatrix(gramMatrix, dofOrdering, basisCache);
ip->computeInnerProductVector(ipVector, v, fxn, dofOrdering, basisCache);
// cout << "physical points for projection:\n" << basisCache->getPhysicalCubaturePoints();
// cout << "gramMatrix:\n" << gramMatrix;
// cout << "ipVector:\n" << ipVector;
map<int,int> oldToNewIndices;
if (fieldIndicesToSkip.size() > 0) {
// the code to do with fieldIndicesToSkip might not be terribly efficient...
// (but it's not likely to be called too frequently)
int i_indices_skipped = 0;
for (int i=0; i<cardinality; i++) {
int new_index;
if (fieldIndicesToSkip.find(i) != fieldIndicesToSkip.end()) {
i_indices_skipped++;
new_index = -1;
} else {
new_index = i - i_indices_skipped;
}
oldToNewIndices[i] = new_index;
}
FieldContainer<double> gramMatrixFiltered(numCells,numDofs,numDofs);
FieldContainer<double> ipVectorFiltered(numCells,numDofs);
// now filter out the values that we're to skip
for (int cellIndex=0; cellIndex<numCells; cellIndex++) {
for (int i=0; i<cardinality; i++) {
int i_filtered = oldToNewIndices[i];
if (i_filtered == -1) {
continue;
}
ipVectorFiltered(cellIndex,i_filtered) = ipVector(cellIndex,i);
for (int j=0; j<cardinality; j++) {
int j_filtered = oldToNewIndices[j];
if (j_filtered == -1) {
continue;
}
gramMatrixFiltered(cellIndex,i_filtered,j_filtered) = gramMatrix(cellIndex,i,j);
}
}
}
// cout << "gramMatrixFiltered:\n" << gramMatrixFiltered;
// cout << "ipVectorFiltered:\n" << ipVectorFiltered;
gramMatrix = gramMatrixFiltered;
ipVector = ipVectorFiltered;
}
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
// TODO: rewrite to take advantage of SerialDenseWrapper...
Epetra_SerialDenseSolver solver;
Epetra_SerialDenseMatrix A(Copy,
&gramMatrix(cellIndex,0,0),
gramMatrix.dimension(2),
gramMatrix.dimension(2),
gramMatrix.dimension(1)); // stride -- fc stores in row-major order (a.o.t. SDM)
Epetra_SerialDenseVector b(Copy,
&ipVector(cellIndex,0),
ipVector.dimension(1));
Epetra_SerialDenseVector x(gramMatrix.dimension(1));
solver.SetMatrix(A);
int info = solver.SetVectors(x,b);
if (info!=0){
cout << "projectFunctionOntoBasis: failed to SetVectors with error " << info << endl;
}
bool equilibrated = false;
if (solver.ShouldEquilibrate()){
solver.EquilibrateMatrix();
solver.EquilibrateRHS();
equilibrated = true;
}
info = solver.Solve();
if (info!=0){
cout << "projectFunctionOntoBasis: failed to solve with error " << info << endl;
}
if (equilibrated) {
int successLocal = solver.UnequilibrateLHS();
if (successLocal != 0) {
cout << "projection: unequilibration FAILED with error: " << successLocal << endl;
}
}
basisCoefficients.resize(numCells,cardinality);
for (int i=0;i<cardinality;i++) {
if (fieldIndicesToSkip.size()==0) {
basisCoefficients(cellIndex,i) = x(i);
} else {
int i_filtered = oldToNewIndices[i];
if (i_filtered==-1) {
basisCoefficients(cellIndex,i) = 0.0;
} else {
basisCoefficients(cellIndex,i) = x(i_filtered);
}
}
}
}
}
bool LobattoBasisTests::testSimpleStiffnessMatrix() {
bool success = true;
int rank = Teuchos::GlobalMPISession::getRank();
VarFactory varFactory;
VarPtr u = varFactory.fieldVar("u");
VarPtr un = varFactory.fluxVar("un_hat");
VarPtr v = varFactory.testVar("v", HGRAD);
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
vector<double> beta;
beta.push_back(1);
beta.push_back(1);
bf->addTerm(beta * u, v->grad());
bf->addTerm(un, v);
DofOrderingPtr trialSpace = Teuchos::rcp( new DofOrdering );
DofOrderingPtr testSpace = Teuchos::rcp( new DofOrdering );
const int numSides = 4;
const int spaceDim = 2;
int fieldOrder = 3;
int testOrder = fieldOrder+2;
BasisPtr fieldBasis = Camellia::intrepidQuadHGRAD(fieldOrder);
BasisPtr fluxBasis = Camellia::intrepidLineHGRAD(fieldOrder);
trialSpace->addEntry(u->ID(), fieldBasis, fieldBasis->rangeRank());
for (int i=0; i<numSides; i++) {
trialSpace->addEntry(un->ID(), fluxBasis, fluxBasis->rangeRank(), i);
}
BasisPtr testBasis = Camellia::lobattoQuadHGRAD(testOrder+1,false); // +1 because it lives in HGRAD
testSpace->addEntry(v->ID(), testBasis, testBasis->rangeRank());
int numTrialDofs = trialSpace->totalDofs();
int numTestDofs = testSpace->totalDofs();
int numCells = 1;
FieldContainer<double> cellNodes(numCells,numSides,spaceDim);
cellNodes(0,0,0) = 0;
cellNodes(0,0,1) = 0;
cellNodes(0,1,0) = 1;
cellNodes(0,1,1) = 0;
cellNodes(0,2,0) = 1;
cellNodes(0,2,1) = 1;
cellNodes(0,3,0) = 0;
cellNodes(0,3,1) = 1;
FieldContainer<double> stiffness(numCells,numTestDofs,numTrialDofs);
FieldContainer<double> cellSideParities(numCells,numSides);
cellSideParities.initialize(1.0);
Teuchos::RCP<shards::CellTopology> quad_4 = Teuchos::rcp( new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ) );
Teuchos::RCP<ElementType> elemType = Teuchos::rcp( new ElementType(trialSpace, testSpace, quad_4));
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType) );
vector<GlobalIndexType> cellIDs;
cellIDs.push_back(0);
basisCache->setPhysicalCellNodes(cellNodes, cellIDs, true);
bf->stiffnessMatrix(stiffness, elemType, cellSideParities, basisCache);
// TODO: finish this test
// cout << stiffness;
if (rank==0)
cout << "Warning: testSimpleStiffnessMatrix() unfinished.\n";
return success;
}
bool LinearTermTests::testMixedTermConsistency()
{
bool success = true;
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr tau = varFactory->testVar("\\tau", HDIV);
VarPtr v = varFactory->testVar("v", HGRAD);
// define trial variables
VarPtr uhat = varFactory->traceVar("\\widehat{u}");
VarPtr beta_n_u_minus_sigma_n = varFactory->fluxVar("\\widehat{\\beta \\cdot n u - \\sigma_{n}}");
VarPtr u = varFactory->fieldVar("u");
VarPtr sigma1 = varFactory->fieldVar("\\sigma_1");
VarPtr sigma2 = varFactory->fieldVar("\\sigma_2");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
double eps = .01;
//////////////////// DEFINE BILINEAR FORM ///////////////////////
BFPtr confusionBF = Teuchos::rcp( new BF(varFactory) );
// tau terms:
confusionBF->addTerm(sigma1 / eps, tau->x());
confusionBF->addTerm(sigma2 / eps, tau->y());
confusionBF->addTerm(u, tau->div());
confusionBF->addTerm(uhat, -tau->dot_normal());
// v terms:
confusionBF->addTerm( sigma1, v->dx() );
confusionBF->addTerm( sigma2, v->dy() );
confusionBF->addTerm( -u, beta * v->grad() );
confusionBF->addTerm( beta_n_u_minus_sigma_n, v);
//////////////////// BUILD MESH ///////////////////////
// define nodes for mesh
int H1Order = 1;
int pToAdd = 1;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 1.0;
quadPoints(1,1) = 0.0;
quadPoints(2,0) = 1.0;
quadPoints(2,1) = 1.0;
quadPoints(3,0) = 0.0;
quadPoints(3,1) = 1.0;
int nCells = 1;
int horizontalCells = nCells, verticalCells = nCells;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> myMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
confusionBF, H1Order, H1Order+pToAdd);
ElementTypePtr elemType = myMesh->getElement(0)->elementType();
// DofOrderingPtr testOrder = elemType->testOrderPtr;
BasisCachePtr basisCache = Teuchos::rcp(new BasisCache(elemType, myMesh, true));
LinearTermPtr integrandIBP = Teuchos::rcp(new LinearTerm);// residual
vector<double> e1(2); // (1,0)
vector<double> e2(2); // (0,1)
e1[0] = 1;
e2[1] = 1;
FunctionPtr n = Function::normal();
FunctionPtr X = Function::xn(1);
FunctionPtr Y = Function::yn(1);
FunctionPtr testFxn1 = X;
FunctionPtr testFxn2 = Y;
FunctionPtr divTestFxn = testFxn1->dx() + testFxn2->dy();
FunctionPtr vectorTest = testFxn1*e1 + testFxn2*e2;
integrandIBP->addTerm(vectorTest*n*v + -vectorTest*v->grad()); // boundary term
// define dummy IP to initialize riesz rep class, but just integrate RHS
IPPtr dummyIP = Teuchos::rcp(new IP);
dummyIP->addTerm(v);
Teuchos::RCP<RieszRep> riesz = Teuchos::rcp(new RieszRep(myMesh, dummyIP, integrandIBP));
map<GlobalIndexType,FieldContainer<double> > rieszRHS = riesz->integrateFunctional();
set<GlobalIndexType> cellIDs = myMesh->cellIDsInPartition();
for (set<GlobalIndexType>::iterator cellIDIt=cellIDs.begin(); cellIDIt !=cellIDs.end(); cellIDIt++)
{
GlobalIndexType cellID = *cellIDIt;
ElementTypePtr elemTypePtr = myMesh->getElementType(cellID);
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
int numTestDofs = testOrderingPtr->totalDofs();
BasisCachePtr basisCache = BasisCache::basisCacheForCell(myMesh, cellID, true);
FieldContainer<double> rhsIBPValues(1,numTestDofs);
integrandIBP->integrate(rhsIBPValues, testOrderingPtr, basisCache);
FieldContainer<double> rieszValues(1,numTestDofs);
(riesz->getFunctional())->integrate(rieszValues, testOrderingPtr, basisCache);
double maxDiff;
double tol = 1e-13;
FieldContainer<double> rhsIBPVals(numTestDofs);
for (int i = 0; i< numTestDofs; i++)
{
rhsIBPVals(i) = rhsIBPValues(0,i);
// cout << "riesz rhs values = " << rieszRHS[cellID](i) << ", rhsIBPValues = " << rhsIBPVals(i) << ", riesz returned values = " << rieszValues(0,i) << endl;
}
bool fcsAgree = TestSuite::fcsAgree(rieszRHS[cellID],rhsIBPVals,tol,maxDiff);
if (!fcsAgree)
{
success=false;
cout << "Failed mixed term consistency test with maxDiff = " << maxDiff << " on cellID " << cellID<< endl;
}
}
return allSuccess(success);
}
int main(int argc, char *argv[])
{
int rank = 0;
#ifdef HAVE_MPI
// TODO: figure out the right thing to do here...
// may want to modify argc and argv before we make the following call:
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
rank=mpiSession.getRank();
#else
#endif
bool useLineSearch = false;
int pToAdd = 2; // for optimal test function approximation
int pToAddForStreamFunction = 2;
double nonlinearStepSize = 1.0;
double dt = 0.5;
double nonlinearRelativeEnergyTolerance = 0.015; // used to determine convergence of the nonlinear solution
// double nonlinearRelativeEnergyTolerance = 0.15; // used to determine convergence of the nonlinear solution
double eps = 1.0/64.0; // width of ramp up to 1.0 for top BC; eps == 0 ==> soln not in H1
// epsilon above is chosen to match our initial 16x16 mesh, to avoid quadrature errors.
// double eps = 0.0; // John Evans's problem: not in H^1
bool enforceLocalConservation = false;
bool enforceOneIrregularity = true;
bool reportPerCellErrors = true;
bool useMumps = true;
int horizontalCells, verticalCells;
int maxIters = 50; // for nonlinear steps
vector<double> ReValues;
// usage: polyOrder [numRefinements]
// parse args:
if (argc < 6)
{
cout << "Usage: NavierStokesCavityFlowContinuationFixedMesh fieldPolyOrder hCells vCells energyErrorGoal Re0 [Re1 ...]\n";
return -1;
}
int polyOrder = atoi(argv[1]);
horizontalCells = atoi(argv[2]);
verticalCells = atoi(argv[3]);
double energyErrorGoal = atof(argv[4]);
for (int i=5; i<argc; i++)
{
ReValues.push_back(atof(argv[i]));
}
if (rank == 0)
{
cout << "L^2 order: " << polyOrder << endl;
cout << "initial mesh size: " << horizontalCells << " x " << verticalCells << endl;
cout << "energy error goal: " << energyErrorGoal << endl;
cout << "Reynolds number values for continuation:\n";
for (int i=0; i<ReValues.size(); i++)
{
cout << ReValues[i] << ", ";
}
cout << endl;
}
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;
// define meshes:
int H1Order = polyOrder + 1;
bool useTriangles = false;
bool meshHasTriangles = useTriangles;
double minL2Increment = 1e-8;
// get variable definitions:
VarFactory varFactory = VGPStokesFormulation::vgpVarFactory();
u1 = varFactory.fieldVar(VGP_U1_S);
u2 = varFactory.fieldVar(VGP_U2_S);
sigma11 = varFactory.fieldVar(VGP_SIGMA11_S);
sigma12 = varFactory.fieldVar(VGP_SIGMA12_S);
sigma21 = varFactory.fieldVar(VGP_SIGMA21_S);
sigma22 = varFactory.fieldVar(VGP_SIGMA22_S);
p = varFactory.fieldVar(VGP_P_S);
u1hat = varFactory.traceVar(VGP_U1HAT_S);
u2hat = varFactory.traceVar(VGP_U2HAT_S);
t1n = varFactory.fluxVar(VGP_T1HAT_S);
t2n = varFactory.fluxVar(VGP_T2HAT_S);
v1 = varFactory.testVar(VGP_V1_S, HGRAD);
v2 = varFactory.testVar(VGP_V2_S, HGRAD);
tau1 = varFactory.testVar(VGP_TAU1_S, HDIV);
tau2 = varFactory.testVar(VGP_TAU2_S, HDIV);
q = varFactory.testVar(VGP_Q_S, HGRAD);
FunctionPtr u1_0 = Teuchos::rcp( new U1_0(eps) );
FunctionPtr u2_0 = Teuchos::rcp( new U2_0 );
FunctionPtr zero = Function::zero();
ParameterFunctionPtr Re_param = ParameterFunction::parameterFunction(1);
VGPNavierStokesProblem problem = VGPNavierStokesProblem(Re_param,quadPoints,
horizontalCells,verticalCells,
H1Order, pToAdd,
u1_0, u2_0, // BC for u
zero, zero); // zero forcing function
SolutionPtr solution = problem.backgroundFlow();
SolutionPtr solnIncrement = problem.solutionIncrement();
Teuchos::RCP<Mesh> mesh = problem.mesh();
mesh->registerSolution(solution);
mesh->registerSolution(solnIncrement);
///////////////////////////////////////////////////////////////////////////
// define bilinear form for stream function:
VarFactory streamVarFactory;
VarPtr phi_hat = streamVarFactory.traceVar("\\widehat{\\phi}");
VarPtr psin_hat = streamVarFactory.fluxVar("\\widehat{\\psi}_n");
VarPtr psi_1 = streamVarFactory.fieldVar("\\psi_1");
VarPtr psi_2 = streamVarFactory.fieldVar("\\psi_2");
VarPtr phi = streamVarFactory.fieldVar("\\phi");
VarPtr q_s = streamVarFactory.testVar("q_s", HGRAD);
VarPtr v_s = streamVarFactory.testVar("v_s", HDIV);
BFPtr streamBF = Teuchos::rcp( new BF(streamVarFactory) );
streamBF->addTerm(psi_1, q_s->dx());
streamBF->addTerm(psi_2, q_s->dy());
streamBF->addTerm(-psin_hat, q_s);
streamBF->addTerm(psi_1, v_s->x());
streamBF->addTerm(psi_2, v_s->y());
streamBF->addTerm(phi, v_s->div());
streamBF->addTerm(-phi_hat, v_s->dot_normal());
Teuchos::RCP<Mesh> streamMesh, overkillMesh;
streamMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
streamBF, H1Order+pToAddForStreamFunction,
H1Order+pToAdd+pToAddForStreamFunction, useTriangles);
mesh->registerObserver(streamMesh); // will refine streamMesh in the same way as mesh.
map<int, double> dofsToL2error; // key: numGlobalDofs, value: total L2error compared with overkill
vector< VarPtr > fields;
fields.push_back(u1);
fields.push_back(u2);
fields.push_back(sigma11);
fields.push_back(sigma12);
fields.push_back(sigma21);
fields.push_back(sigma22);
fields.push_back(p);
if (rank == 0)
{
cout << "Starting mesh has " << horizontalCells << " x " << verticalCells << " elements and ";
cout << mesh->numGlobalDofs() << " total dofs.\n";
cout << "polyOrder = " << polyOrder << endl;
cout << "pToAdd = " << pToAdd << endl;
cout << "eps for top BC = " << eps << endl;
if (useTriangles)
{
cout << "Using triangles.\n";
}
if (enforceLocalConservation)
{
cout << "Enforcing local conservation.\n";
}
else
{
cout << "NOT enforcing local conservation.\n";
}
if (enforceOneIrregularity)
{
cout << "Enforcing 1-irregularity.\n";
}
else
{
cout << "NOT enforcing 1-irregularity.\n";
}
}
//////////////////// CREATE BCs ///////////////////////
SpatialFilterPtr entireBoundary = Teuchos::rcp( new SpatialFilterUnfiltered );
FunctionPtr u1_prev = Function::solution(u1,solution);
FunctionPtr u2_prev = Function::solution(u2,solution);
FunctionPtr u1hat_prev = Function::solution(u1hat,solution);
FunctionPtr u2hat_prev = Function::solution(u2hat,solution);
//////////////////// SOLVE & REFINE ///////////////////////
FunctionPtr vorticity = Teuchos::rcp( new PreviousSolutionFunction(solution, - u1->dy() + u2->dx() ) );
// FunctionPtr vorticity = Teuchos::rcp( new PreviousSolutionFunction(solution,sigma12 - sigma21) );
RHSPtr streamRHS = RHS::rhs();
streamRHS->addTerm(vorticity * q_s);
((PreviousSolutionFunction*) vorticity.get())->setOverrideMeshCheck(true);
((PreviousSolutionFunction*) u1_prev.get())->setOverrideMeshCheck(true);
((PreviousSolutionFunction*) u2_prev.get())->setOverrideMeshCheck(true);
BCPtr streamBC = BC::bc();
// streamBC->addDirichlet(psin_hat, entireBoundary, u0_cross_n);
streamBC->addDirichlet(phi_hat, entireBoundary, zero);
// streamBC->addZeroMeanConstraint(phi);
IPPtr streamIP = Teuchos::rcp( new IP );
streamIP->addTerm(q_s);
streamIP->addTerm(q_s->grad());
streamIP->addTerm(v_s);
streamIP->addTerm(v_s->div());
SolutionPtr streamSolution = Teuchos::rcp( new Solution( streamMesh, streamBC, streamRHS, streamIP ) );
if (enforceLocalConservation)
{
FunctionPtr zero = Function::zero();
solution->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y()==zero);
solnIncrement->lagrangeConstraints()->addConstraint(u1hat->times_normal_x() + u2hat->times_normal_y()==zero);
}
if (true)
{
FunctionPtr u1_incr = Function::solution(u1, solnIncrement);
FunctionPtr u2_incr = Function::solution(u2, solnIncrement);
FunctionPtr sigma11_incr = Function::solution(sigma11, solnIncrement);
FunctionPtr sigma12_incr = Function::solution(sigma12, solnIncrement);
FunctionPtr sigma21_incr = Function::solution(sigma21, solnIncrement);
FunctionPtr sigma22_incr = Function::solution(sigma22, solnIncrement);
FunctionPtr p_incr = Function::solution(p, solnIncrement);
FunctionPtr l2_incr = u1_incr * u1_incr + u2_incr * u2_incr + p_incr * p_incr
+ sigma11_incr * sigma11_incr + sigma12_incr * sigma12_incr
+ sigma21_incr * sigma21_incr + sigma22_incr * sigma22_incr;
double energyThreshold = 0.20;
Teuchos::RCP< RefinementStrategy > refinementStrategy = Teuchos::rcp( new RefinementStrategy( solnIncrement, energyThreshold ));
for (int i=0; i<ReValues.size(); i++)
{
double Re = ReValues[i];
Re_param->setValue(Re);
if (rank==0) cout << "Solving with Re = " << Re << ":\n";
double energyErrorTotal;
do
{
double incr_norm;
do
{
problem.iterate(useLineSearch);
incr_norm = sqrt(l2_incr->integrate(problem.mesh()));
if (rank==0)
{
cout << "\x1B[2K"; // Erase the entire current line.
cout << "\x1B[0E"; // Move to the beginning of the current line.
cout << "Iteration: " << problem.iterationCount() << "; L^2(incr) = " << incr_norm;
flush(cout);
}
}
while ((incr_norm > minL2Increment ) && (problem.iterationCount() < maxIters));
if (rank==0) cout << endl;
problem.setIterationCount(1); // 1 means reuse background flow (which we must, given that we want continuation in Re...)
energyErrorTotal = solnIncrement->energyErrorTotal(); //solution->energyErrorTotal();
if (energyErrorTotal > energyErrorGoal)
{
refinementStrategy->refine(false);
}
if (rank==0)
{
cout << "Energy error: " << energyErrorTotal << endl;
}
}
while (energyErrorTotal > energyErrorGoal);
}
}
double energyErrorTotal = solution->energyErrorTotal();
double incrementalEnergyErrorTotal = solnIncrement->energyErrorTotal();
if (rank == 0)
{
cout << "final mesh has " << mesh->numActiveElements() << " elements and " << mesh->numGlobalDofs() << " dofs.\n";
cout << "energy error: " << energyErrorTotal << endl;
cout << " (Incremental solution's energy error is " << incrementalEnergyErrorTotal << ".)\n";
}
FunctionPtr u1_sq = u1_prev * u1_prev;
FunctionPtr u_dot_u = u1_sq + (u2_prev * u2_prev);
FunctionPtr u_mag = Teuchos::rcp( new SqrtFunction( u_dot_u ) );
FunctionPtr u_div = Teuchos::rcp( new PreviousSolutionFunction(solution, u1->dx() + u2->dy() ) );
FunctionPtr massFlux = Teuchos::rcp( new PreviousSolutionFunction(solution, u1hat->times_normal_x() + u2hat->times_normal_y()) );
// check that the zero mean pressure is being correctly imposed:
FunctionPtr p_prev = Teuchos::rcp( new PreviousSolutionFunction(solution,p) );
double p_avg = p_prev->integrate(mesh);
if (rank==0)
cout << "Integral of pressure: " << p_avg << endl;
// integrate massFlux over each element (a test):
// fake a new bilinear form so we can integrate against 1
VarPtr testOne = varFactory.testVar("1",CONSTANT_SCALAR);
BFPtr fakeBF = Teuchos::rcp( new BF(varFactory) );
LinearTermPtr massFluxTerm = massFlux * testOne;
CellTopoPtrLegacy quadTopoPtr = Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >() ));
DofOrderingFactory dofOrderingFactory(fakeBF);
int fakeTestOrder = H1Order;
DofOrderingPtr testOrdering = dofOrderingFactory.testOrdering(fakeTestOrder, *quadTopoPtr);
int testOneIndex = testOrdering->getDofIndex(testOne->ID(),0);
vector< ElementTypePtr > elemTypes = mesh->elementTypes(); // global element types
map<int, double> massFluxIntegral; // cellID -> integral
double maxMassFluxIntegral = 0.0;
double totalMassFlux = 0.0;
double totalAbsMassFlux = 0.0;
double maxCellMeasure = 0;
double minCellMeasure = 1;
for (vector< ElementTypePtr >::iterator elemTypeIt = elemTypes.begin(); elemTypeIt != elemTypes.end(); elemTypeIt++)
{
ElementTypePtr elemType = *elemTypeIt;
vector< ElementPtr > elems = mesh->elementsOfTypeGlobal(elemType);
vector<GlobalIndexType> cellIDs;
for (int i=0; i<elems.size(); i++)
{
cellIDs.push_back(elems[i]->cellID());
}
FieldContainer<double> physicalCellNodes = mesh->physicalCellNodesGlobal(elemType);
BasisCachePtr basisCache = Teuchos::rcp( new BasisCache(elemType,mesh,polyOrder) ); // enrich by trial space order
basisCache->setPhysicalCellNodes(physicalCellNodes,cellIDs,true); // true: create side caches
FieldContainer<double> cellMeasures = basisCache->getCellMeasures();
FieldContainer<double> fakeRHSIntegrals(elems.size(),testOrdering->totalDofs());
massFluxTerm->integrate(fakeRHSIntegrals,testOrdering,basisCache,true); // true: force side evaluation
// cout << "fakeRHSIntegrals:\n" << fakeRHSIntegrals;
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
// pick out the ones for testOne:
massFluxIntegral[cellID] = fakeRHSIntegrals(i,testOneIndex);
}
// find the largest:
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
}
for (int i=0; i<elems.size(); i++)
{
int cellID = cellIDs[i];
maxCellMeasure = max(maxCellMeasure,cellMeasures(i));
minCellMeasure = min(minCellMeasure,cellMeasures(i));
maxMassFluxIntegral = max(abs(massFluxIntegral[cellID]), maxMassFluxIntegral);
totalMassFlux += massFluxIntegral[cellID];
totalAbsMassFlux += abs( massFluxIntegral[cellID] );
}
}
if (rank==0)
{
cout << "largest mass flux: " << maxMassFluxIntegral << endl;
cout << "total mass flux: " << totalMassFlux << endl;
cout << "sum of mass flux absolute value: " << totalAbsMassFlux << endl;
cout << "largest h: " << sqrt(maxCellMeasure) << endl;
cout << "smallest h: " << sqrt(minCellMeasure) << endl;
cout << "ratio of largest / smallest h: " << sqrt(maxCellMeasure) / sqrt(minCellMeasure) << endl;
}
if (rank == 0)
{
cout << "phi ID: " << phi->ID() << endl;
cout << "psi1 ID: " << psi_1->ID() << endl;
cout << "psi2 ID: " << psi_2->ID() << endl;
cout << "streamMesh has " << streamMesh->numActiveElements() << " elements.\n";
cout << "solving for approximate stream function...\n";
}
streamSolution->solve(useMumps);
energyErrorTotal = streamSolution->energyErrorTotal();
if (rank == 0)
{
cout << "...solved.\n";
cout << "Stream mesh has energy error: " << energyErrorTotal << endl;
}
if (rank==0)
{
solution->writeToVTK("nsCavitySoln.vtk");
if (! meshHasTriangles )
{
massFlux->writeBoundaryValuesToMATLABFile(solution->mesh(), "massFlux.dat");
u_mag->writeValuesToMATLABFile(solution->mesh(), "u_mag.m");
u_div->writeValuesToMATLABFile(solution->mesh(), "u_div.m");
solution->writeFieldsToFile(u1->ID(), "u1.m");
solution->writeFluxesToFile(u1hat->ID(), "u1_hat.dat");
solution->writeFieldsToFile(u2->ID(), "u2.m");
solution->writeFluxesToFile(u2hat->ID(), "u2_hat.dat");
solution->writeFieldsToFile(p->ID(), "p.m");
streamSolution->writeFieldsToFile(phi->ID(), "phi.m");
streamSolution->writeFluxesToFile(phi_hat->ID(), "phi_hat.dat");
streamSolution->writeFieldsToFile(psi_1->ID(), "psi1.m");
streamSolution->writeFieldsToFile(psi_2->ID(), "psi2.m");
vorticity->writeValuesToMATLABFile(streamMesh, "vorticity.m");
FunctionPtr ten = Teuchos::rcp( new ConstantScalarFunction(10) );
ten->writeBoundaryValuesToMATLABFile(solution->mesh(), "skeleton.dat");
cout << "wrote files: u_mag.m, u_div.m, u1.m, u1_hat.dat, u2.m, u2_hat.dat, p.m, phi.m, vorticity.m.\n";
}
else
{
solution->writeToFile(u1->ID(), "u1.dat");
solution->writeToFile(u2->ID(), "u2.dat");
solution->writeToFile(u2->ID(), "p.dat");
cout << "wrote files: u1.dat, u2.dat, p.dat\n";
}
FieldContainer<double> points = pointGrid(0, 1, 0, 1, 100);
FieldContainer<double> pointData = solutionData(points, streamSolution, phi);
GnuPlotUtil::writeXYPoints("phi_patch_navierStokes_cavity.dat", pointData);
set<double> patchContourLevels = diagonalContourLevels(pointData,1);
vector<string> patchDataPath;
patchDataPath.push_back("phi_patch_navierStokes_cavity.dat");
GnuPlotUtil::writeContourPlotScript(patchContourLevels, patchDataPath, "lidCavityNavierStokes.p");
GnuPlotUtil::writeExactMeshSkeleton("lid_navierStokes_continuation_adaptive", mesh, 2);
writePatchValues(0, 1, 0, 1, streamSolution, phi, "phi_patch.m");
writePatchValues(0, .1, 0, .1, streamSolution, phi, "phi_patch_detail.m");
writePatchValues(0, .01, 0, .01, streamSolution, phi, "phi_patch_minute_detail.m");
writePatchValues(0, .001, 0, .001, streamSolution, phi, "phi_patch_minute_minute_detail.m");
}
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 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;
}