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[]) {
// 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;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
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
// problem parameters:
int spaceDim = 2;
double Re = 40;
bool steady = false;
string problemChoice = "TaylorGreen";
int numRefs = 1;
int p = 2, delta_p = 2;
int numXElems = 1;
int numTElems = 1;
int numSlabs = 1;
bool useConformingTraces = false;
string solverChoice = "KLU";
string multigridStrategyString = "W-cycle";
bool useCondensedSolve = false;
bool useConjugateGradient = true;
bool logFineOperator = false;
// double solverTolerance = 1e-8;
double nonlinearTolerance = 1e-5;
// int maxLinearIterations = 10000;
int maxNonlinearIterations = 20;
int cgMaxIterations = 10000;
double cgTol = 1e-8;
bool computeL2Error = false;
bool exportSolution = false;
bool saveSolution = false;
bool loadSolution = false;
int loadRef = 0;
int loadDirRef = 0;
string norm = "Graph";
string rootDir = ".";
string tag="";
cmdp.setOption("spaceDim", &spaceDim, "spatial dimension");
cmdp.setOption("Re", &Re, "Re");
cmdp.setOption("steady", "transient", &steady, "use steady incompressible Navier-Stokes");
cmdp.setOption("problem", &problemChoice, "Kovasznay, TaylorGreen");
cmdp.setOption("polyOrder",&p,"polynomial order for field variable u");
cmdp.setOption("delta_p", &delta_p, "test space polynomial order enrichment");
cmdp.setOption("numRefs",&numRefs,"number of refinements");
cmdp.setOption("numXElems",&numXElems,"number of elements in x direction");
cmdp.setOption("numTElems",&numTElems,"number of elements in t direction");
cmdp.setOption("numSlabs",&numSlabs,"number of time slabs to use");
cmdp.setOption("norm", &norm, "norm");
cmdp.setOption("conformingTraces", "nonconformingTraces", &useConformingTraces, "use conforming traces");
cmdp.setOption("solver", &solverChoice, "KLU, SuperLU, MUMPS, GMG-Direct, GMG-ILU, GMG-IC");
cmdp.setOption("multigridStrategy", &multigridStrategyString, "Multigrid strategy: V-cycle, W-cycle, Full, or Two-level");
cmdp.setOption("useCondensedSolve", "useStandardSolve", &useCondensedSolve);
cmdp.setOption("CG", "GMRES", &useConjugateGradient);
cmdp.setOption("logFineOperator", "dontLogFineOperator", &logFineOperator);
// cmdp.setOption("solverTolerance", &solverTolerance, "iterative solver tolerance");
cmdp.setOption("nonlinearTolerance", &nonlinearTolerance, "nonlinear solver tolerance");
// cmdp.setOption("maxLinearIterations", &maxLinearIterations, "maximum number of iterations for linear solver");
cmdp.setOption("maxNonlinearIterations", &maxNonlinearIterations, "maximum number of iterations for Newton solver");
cmdp.setOption("exportDir", &rootDir, "export directory");
cmdp.setOption("computeL2Error", "skipL2Error", &computeL2Error, "compute L2 error");
cmdp.setOption("exportSolution", "skipExport", &exportSolution, "export solution to HDF5");
cmdp.setOption("saveSolution", "skipSave", &saveSolution, "save mesh and solution to HDF5");
cmdp.setOption("loadSolution", "skipLoad", &loadSolution, "load mesh and solution from HDF5");
cmdp.setOption("loadRef", &loadRef, "load refinement number");
cmdp.setOption("loadDirRef", &loadDirRef, "which refinement directory to load from");
cmdp.setOption("tag", &tag, "output tag");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
{
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
map<string, Teuchos::RCP<IncompressibleProblem>> problems;
problems["ManufacturedSolution"] = Teuchos::rcp(new IncompressibleManufacturedSolution(steady, Re, numXElems));
problems["Kovasznay"] = Teuchos::rcp(new KovasznayProblem(steady, Re));
problems["TaylorGreen"] = Teuchos::rcp(new TaylorGreenProblem(steady, Re, numXElems, numSlabs));
problems["Cylinder"] = Teuchos::rcp(new CylinderProblem(steady, Re, numSlabs));
problems["SquareCylinder"] = Teuchos::rcp(new SquareCylinderProblem(steady, Re, numSlabs));
Teuchos::RCP<IncompressibleProblem> problem = problems.at(problemChoice);
// if (commRank == 0)
// {
// Solver::printAvailableSolversReport();
// cout << endl;
// }
Teuchos::RCP<Time> totalTimer = Teuchos::TimeMonitor::getNewCounter("Total Time");
totalTimer->start(true);
for (; problem->currentStep() < problem->numSlabs(); problem->advanceStep())
{
if (problem->numSlabs() > 1 && commRank == 0 && !steady)
cout << "Solving time slab [" << problem->currentT0() << ", " << problem->currentT1() << "]" << endl;
ostringstream problemName;
string isSteady = "Steady";
if (!steady)
isSteady = "Transient";
problemName << isSteady << problemChoice << spaceDim << "D_slab" << problem->currentStep() << "_" << norm << "_" << Re << "_p" << p << "_" << solverChoice;
if (tag != "")
problemName << "_" << tag;
ostringstream saveDir;
saveDir << problemName.str() << "_ref" << loadRef;
int success = mkdir((rootDir+"/"+saveDir.str()).c_str(), S_IRWXU | S_IRWXG);
string dataFileLocation = rootDir + "/" + saveDir.str() + "/" + saveDir.str() + ".data";
string exportName = saveDir.str();
ostringstream loadDir;
loadDir << problemName.str() << "_ref" << loadDirRef;
string loadFilePrefix = "";
if (loadSolution)
{
loadFilePrefix = rootDir + "/" + loadDir.str() + "/" + saveDir.str();
if (commRank == 0) cout << "Loading previous solution " << loadFilePrefix << endl;
}
// ostringstream saveDir;
// saveDir << problemName.str() << "_ref" << loadRef;
string saveFilePrefix = rootDir + "/" + saveDir.str() + "/" + problemName.str();
if (saveSolution && commRank == 0) cout << "Saving to " << saveFilePrefix << endl;
Teuchos::ParameterList parameters;
parameters.set("spaceDim", spaceDim);
parameters.set("steady", steady);
parameters.set("mu", 1./Re);
parameters.set("useConformingTraces", useConformingTraces);
parameters.set("fieldPolyOrder", p);
parameters.set("delta_p", delta_p);
parameters.set("numTElems", numTElems);
parameters.set("norm", norm);
parameters.set("savedSolutionAndMeshPrefix", loadFilePrefix);
SpaceTimeIncompressibleFormulationPtr form = Teuchos::rcp(new SpaceTimeIncompressibleFormulation(problem, parameters));
MeshPtr mesh = form->solutionUpdate()->mesh();
vector<MeshPtr> meshesCoarseToFine;
MeshPtr k0Mesh = Teuchos::rcp( new Mesh (mesh->getTopology()->deepCopy(), form->bf(), 1, delta_p) );
meshesCoarseToFine.push_back(k0Mesh);
meshesCoarseToFine.push_back(mesh);
// mesh->registerObserver(k0Mesh);
// Set up boundary conditions
problem->setBCs(form);
// Set up solution
SolutionPtr solutionUpdate = form->solutionUpdate();
SolutionPtr solutionBackground = form->solutionBackground();
// dynamic_cast<AnalyticalIncompressibleProblem*>(problem.get())->projectExactSolution(solutionBackground);
RefinementStrategyPtr refStrategy = form->getRefinementStrategy();
Teuchos::RCP<HDF5Exporter> exporter;
if (exportSolution)
exporter = Teuchos::rcp(new HDF5Exporter(mesh,exportName, rootDir));
Teuchos::RCP<Time> solverTime = Teuchos::TimeMonitor::getNewCounter("Solve Time");
map<string, SolverPtr> solvers;
solvers["KLU"] = Solver::getSolver(Solver::KLU, true);
#if defined(HAVE_AMESOS_SUPERLUDIST) || defined(HAVE_AMESOS2_SUPERLUDIST)
solvers["SuperLUDist"] = Solver::getSolver(Solver::SuperLUDist, true);
#endif
#ifdef HAVE_AMESOS_MUMPS
solvers["MUMPS"] = Solver::getSolver(Solver::MUMPS, true);
#endif
bool useStaticCondensation = false;
GMGOperator::MultigridStrategy multigridStrategy;
if (multigridStrategyString == "Two-level")
{
multigridStrategy = GMGOperator::TWO_LEVEL;
}
else if (multigridStrategyString == "W-cycle")
{
multigridStrategy = GMGOperator::W_CYCLE;
}
else if (multigridStrategyString == "V-cycle")
{
multigridStrategy = GMGOperator::V_CYCLE;
}
else if (multigridStrategyString == "Full-V")
{
multigridStrategy = GMGOperator::FULL_MULTIGRID_V;
}
else if (multigridStrategyString == "Full-W")
{
multigridStrategy = GMGOperator::FULL_MULTIGRID_W;
}
else
{
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "unrecognized multigrid strategy");
}
ofstream dataFile(dataFileLocation);
dataFile << "ref\t " << "elements\t " << "dofs\t " << "energy\t " << "l2\t " << "solvetime\t" << "iterations\t " << endl;
// {
// // ostringstream saveFile;
// // saveFile << saveFilePrefix << "_ref" << -1;
// // form->save(saveFile.str());
// exporter->exportSolution(solutionBackground, -1);
// if (commRank == 0)
// cout << "Done exporting" << endl;
// }
for (int refIndex=loadRef; refIndex <= numRefs; refIndex++)
{
double l2Update = 1e10;
int iterCount = 0;
solverTime->start(true);
Teuchos::RCP<GMGSolver> gmgSolver;
if (solverChoice[0] == 'G')
{
// gmgSolver = Teuchos::rcp( new GMGSolver(solutionUpdate, k0Mesh, maxLinearIterations, solverTolerance, Solver::getDirectSolver(true), useStaticCondensation));
bool reuseFactorization = true;
SolverPtr coarseSolver = Solver::getDirectSolver(reuseFactorization);
gmgSolver = Teuchos::rcp(new GMGSolver(solutionUpdate, meshesCoarseToFine, cgMaxIterations, cgTol, multigridStrategy, coarseSolver, useCondensedSolve));
gmgSolver->setUseConjugateGradient(useConjugateGradient);
int azOutput = 20; // print residual every 20 CG iterations
gmgSolver->setAztecOutput(azOutput);
gmgSolver->gmgOperator()->setNarrateOnRankZero(logFineOperator,"finest GMGOperator");
// gmgSolver->setAztecOutput(azOutput);
// if (solverChoice == "GMG-Direct")
// gmgSolver->gmgOperator()->setSchwarzFactorizationType(GMGOperator::Direct);
// if (solverChoice == "GMG-ILU")
// gmgSolver->gmgOperator()->setSchwarzFactorizationType(GMGOperator::ILU);
// if (solverChoice == "GMG-IC")
// gmgSolver->gmgOperator()->setSchwarzFactorizationType(GMGOperator::IC);
}
while (l2Update > nonlinearTolerance && iterCount < maxNonlinearIterations)
{
if (solverChoice[0] == 'G')
solutionUpdate->solve(gmgSolver);
else
solutionUpdate->condensedSolve(solvers[solverChoice]);
// Compute L2 norm of update
double u1L2Update = solutionUpdate->L2NormOfSolutionGlobal(form->u(1)->ID());
double u2L2Update = solutionUpdate->L2NormOfSolutionGlobal(form->u(2)->ID());
l2Update = sqrt(u1L2Update*u1L2Update + u2L2Update*u2L2Update);
if (commRank == 0)
cout << "Nonlinear Update:\t " << l2Update << endl;
form->updateSolution();
iterCount++;
}
double solveTime = solverTime->stop();
double energyError = solutionUpdate->energyErrorTotal();
double l2Error = 0;
if (computeL2Error)
{
l2Error = problem->computeL2Error(form, solutionBackground);
}
if (commRank == 0)
{
cout << "Refinement: " << refIndex
<< " \tElements: " << mesh->numActiveElements()
<< " \tDOFs: " << mesh->numGlobalDofs()
<< " \tEnergy Error: " << energyError
<< " \tL2 Error: " << l2Error
<< " \tSolve Time: " << solveTime
<< " \tTotal Time: " << totalTimer->totalElapsedTime(true)
// << " \tIteration Count: " << iterationCount
<< endl;
dataFile << refIndex
<< " " << mesh->numActiveElements()
<< " " << mesh->numGlobalDofs()
<< " " << energyError
<< " " << l2Error
<< " " << solveTime
<< " " << totalTimer->totalElapsedTime(true)
// << " " << iterationCount
<< endl;
}
if (exportSolution)
exporter->exportSolution(solutionBackground, refIndex);
if (saveSolution)
{
ostringstream saveFile;
saveFile << saveFilePrefix << "_ref" << refIndex;
form->save(saveFile.str());
}
if (refIndex != numRefs)
{
// k0Mesh = Teuchos::rcp( new Mesh (mesh->getTopology()->deepCopy(), form->bf(), 1, delta_p) );
// meshesCoarseToFine.push_back(k0Mesh);
refStrategy->refine();
meshesCoarseToFine.push_back(mesh);
}
}
dataFile.close();
}
double totalTime = totalTimer->stop();
if (commRank == 0)
cout << "Total time = " << totalTime << endl;
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv,0);
choice::MpiArgs args( argc, argv );
#else
choice::Args args( argc, argv );
#endif
int commRank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
// Required arguments
int numRefs = args.Input<int>("--numRefs", "number of refinement steps");
bool enforceLocalConservation = args.Input<bool>("--conserve", "enforce local conservation");
bool steady = args.Input<bool>("--steady", "run steady rather than transient");
// Optional arguments (have defaults)
double dt = args.Input("--dt", "time step", 0.25);
int numTimeSteps = args.Input("--nt", "number of time steps", 20);
halfWidth = args.Input("--halfWidth", "half width of inlet profile", 1.0);
args.Process();
//////////////////// DECLARE VARIABLES ///////////////////////
// define test variables
VarFactory varFactory;
VarPtr v = varFactory.testVar("v", HGRAD);
// define trial variables
VarPtr beta_n_u_hat = varFactory.fluxVar("\\widehat{\\beta \\cdot n }");
VarPtr u = varFactory.fieldVar("u");
vector<double> beta;
beta.push_back(1.0);
beta.push_back(0.0);
//////////////////// BUILD MESH ///////////////////////
BFPtr bf = Teuchos::rcp( new BF(varFactory) );
// define nodes for mesh
FieldContainer<double> meshBoundary(4,2);
meshBoundary(0,0) = 0.0; // x1
meshBoundary(0,1) = -2.0; // y1
meshBoundary(1,0) = 4.0;
meshBoundary(1,1) = -2.0;
meshBoundary(2,0) = 4.0;
meshBoundary(2,1) = 2.0;
meshBoundary(3,0) = 0.0;
meshBoundary(3,1) = 2.0;
int horizontalCells = 8, verticalCells = 8;
// create a pointer to a new mesh:
Teuchos::RCP<Mesh> mesh = Mesh::buildQuadMesh(meshBoundary, horizontalCells, verticalCells,
bf, H1Order, H1Order+pToAdd);
////////////////////////////////////////////////////////////////////
// INITIALIZE FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr prevTimeFlow = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
SolutionPtr flowResidual = Teuchos::rcp(new Solution(mesh, nullBC, nullRHS, nullIP) );
FunctionPtr u_prev_time = Teuchos::rcp( new PreviousSolutionFunction(prevTimeFlow, u) );
//////////////////// DEFINE BILINEAR FORM ///////////////////////
Teuchos::RCP<RHSEasy> rhs = Teuchos::rcp( new RHSEasy );
FunctionPtr invDt = Teuchos::rcp(new ScalarParamFunction(1.0/dt));
// v terms:
bf->addTerm( beta * u, - v->grad() );
bf->addTerm( beta_n_u_hat, v);
if (!steady)
{
bf->addTerm( u, invDt*v );
rhs->addTerm( u_prev_time * invDt * v );
}
//////////////////// SPECIFY RHS ///////////////////////
FunctionPtr f = Teuchos::rcp( new ConstantScalarFunction(0.0) );
rhs->addTerm( f * v ); // obviously, with f = 0 adding this term is not necessary!
//////////////////// DEFINE INNER PRODUCT(S) ///////////////////////
IPPtr ip = bf->graphNorm();
// ip->addTerm(v);
// ip->addTerm(beta*v->grad());
//////////////////// CREATE BCs ///////////////////////
Teuchos::RCP<BCEasy> bc = Teuchos::rcp( new BCEasy );
SpatialFilterPtr lBoundary = Teuchos::rcp( new LeftBoundary );
FunctionPtr u1 = Teuchos::rcp( new InletBC );
bc->addDirichlet(beta_n_u_hat, lBoundary, -u1);
Teuchos::RCP<Solution> solution = Teuchos::rcp( new Solution(mesh, bc, rhs, ip) );
// ==================== Register Solutions ==========================
mesh->registerSolution(solution);
mesh->registerSolution(prevTimeFlow);
mesh->registerSolution(flowResidual);
// ==================== SET INITIAL GUESS ==========================
double u_free = 0.0;
map<int, Teuchos::RCP<Function> > functionMap;
// functionMap[u->ID()] = Teuchos::rcp( new ConInletBC
functionMap[u->ID()] = Teuchos::rcp( new InletBC );
prevTimeFlow->projectOntoMesh(functionMap);
//////////////////// SOLVE & REFINE ///////////////////////
if (enforceLocalConservation)
{
if (steady)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(beta_n_u_hat == zero);
}
else
{
// FunctionPtr parity = Teuchos::rcp<Function>( new SideParityFunction );
// LinearTermPtr conservedQuantity = Teuchos::rcp<LinearTerm>( new LinearTerm(parity, beta_n_u_minus_sigma_n) );
LinearTermPtr conservedQuantity = Teuchos::rcp<LinearTerm>( new LinearTerm(1.0, beta_n_u_hat) );
LinearTermPtr sourcePart = Teuchos::rcp<LinearTerm>( new LinearTerm(invDt, u) );
conservedQuantity->addTerm(sourcePart, true);
solution->lagrangeConstraints()->addConstraint(conservedQuantity == u_prev_time * invDt);
}
}
double energyThreshold = 0.2; // for mesh refinements
RefinementStrategy refinementStrategy( solution, energyThreshold );
VTKExporter exporter(solution, mesh, varFactory);
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
if (steady)
{
solution->solve(false);
if (commRank == 0)
{
stringstream outfile;
outfile << "Convection_" << refIndex;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_hat) );
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
Teuchos::Tuple<double, 3> fluxImbalances = checkConservation(flux, zero, varFactory, mesh);
cout << "Mass flux: Largest Local = " << fluxImbalances[0]
<< ", Global = " << fluxImbalances[1] << ", Sum Abs = " << fluxImbalances[2] << endl;
}
}
else
{
int timestepCount = 0;
double time_tol = 1e-8;
double L2_time_residual = 1e9;
// cout << L2_time_residual <<" "<< time_tol << timestepCount << numTimeSteps << endl;
while((L2_time_residual > time_tol) && (timestepCount < numTimeSteps))
{
solution->solve(false);
// Subtract solutions to get residual
flowResidual->setSolution(solution);
flowResidual->addSolution(prevTimeFlow, -1.0);
L2_time_residual = flowResidual->L2NormOfSolutionGlobal(u->ID());
if (commRank == 0)
{
cout << endl << "Timestep: " << timestepCount << ", dt = " << dt << ", Time residual = " << L2_time_residual << endl;
stringstream outfile;
outfile << "TransientConvection_" << refIndex << "-" << timestepCount;
exporter.exportSolution(outfile.str());
// Check local conservation
FunctionPtr flux = Teuchos::rcp( new PreviousSolutionFunction(solution, beta_n_u_hat) );
FunctionPtr source = Teuchos::rcp( new PreviousSolutionFunction(flowResidual, u) );
source = -invDt * source;
Teuchos::Tuple<double, 3> fluxImbalances = checkConservation(flux, source, varFactory, mesh);
cout << "Mass flux: Largest Local = " << fluxImbalances[0]
<< ", Global = " << fluxImbalances[1] << ", Sum Abs = " << fluxImbalances[2] << endl;
}
prevTimeFlow->setSolution(solution); // reset previous time solution to current time sol
timestepCount++;
}
}
if (refIndex < numRefs)
refinementStrategy.refine(commRank==0); // print to console on commRank 0
}
return 0;
}
