map<GlobalIndexType,FieldContainer<double> > RieszRep::integrateRHS() {
// NVR: changed this to only return integrated values for rank-local cells.
map<GlobalIndexType,FieldContainer<double> > cellRHS;
set<GlobalIndexType> cellIDs = _mesh->cellIDsInPartition();
for (set<GlobalIndexType>::iterator cellIDIt=cellIDs.begin(); cellIDIt !=cellIDs.end(); cellIDIt++){
GlobalIndexType cellID = *cellIDIt;
ElementTypePtr elemTypePtr = _mesh->getElementType(cellID);
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
int numTestDofs = testOrderingPtr->totalDofs();
int cubEnrich = 0; // set to zero for release
BasisCachePtr basisCache = BasisCache::basisCacheForCell(_mesh,cellID,true,cubEnrich);
FieldContainer<double> rhsValues(1,numTestDofs);
_rhs->integrate(rhsValues, testOrderingPtr, basisCache);
FieldContainer<double> rhsVals(numTestDofs);
for (int i = 0;i<numTestDofs;i++){
rhsVals(i) = rhsValues(0,i);
}
cellRHS[cellID] = rhsVals;
}
return cellRHS;
}
double MeshUtilities::computeMaxLocalConditionNumber(Teuchos::RCP< DPGInnerProduct > ip, MeshPtr mesh, bool jacobiScaling, string sparseFileToWriteTo) {
int rank = Teuchos::GlobalMPISession::getRank();
int numProcs = Teuchos::GlobalMPISession::getNProc();
vector< ElementPtr > elements = mesh->elementsInPartition(rank);
// cout << "Checking condition numbers on rank " << rank << endl;
FieldContainer<double> maxConditionNumberIPMatrix;
int maxCellID = -1;
double myMaxConditionNumber = -1;
for (vector< ElementPtr >::iterator elemIt = elements.begin(); elemIt != elements.end(); elemIt++) {
int cellID = (*elemIt)->cellID();
bool testVsTest = true;
BasisCachePtr cellBasisCache = BasisCache::basisCacheForCell(mesh, cellID, testVsTest);
DofOrderingPtr testSpace = (*elemIt)->elementType()->testOrderPtr;
int testDofs = testSpace->totalDofs();
int numCells = 1;
FieldContainer<double> innerProductMatrix(numCells,testDofs,testDofs);
ip->computeInnerProductMatrix(innerProductMatrix, testSpace, cellBasisCache);
// reshape:
innerProductMatrix.resize(testDofs,testDofs);
if (jacobiScaling)
SerialDenseMatrixUtility::jacobiScaleMatrix(innerProductMatrix);
// double conditionNumber = SerialDenseMatrixUtility::estimate1NormConditionNumber(innerProductMatrix);
double conditionNumber = SerialDenseMatrixUtility::estimate2NormConditionNumber(innerProductMatrix);
if (conditionNumber > myMaxConditionNumber) {
myMaxConditionNumber = conditionNumber;
maxConditionNumberIPMatrix = innerProductMatrix;
maxCellID = cellID;
} else if (maxConditionNumberIPMatrix.size()==0) {
// could be that the estimation failed--we still want a copy of the matrix written to file.
maxConditionNumberIPMatrix = innerProductMatrix;
}
}
// cout << "Determined condition numbers on rank " << rank << endl;
FieldContainer<double> maxConditionNumbers(numProcs);
maxConditionNumbers[rank] = myMaxConditionNumber;
MPIWrapper::entryWiseSum(maxConditionNumbers);
double maxConditionNumber = maxConditionNumbers[0];
int maxConditionNumberOwner = 0; // the MPI node with the max condition number
for (int i=1; i<numProcs; i++) {
if (maxConditionNumber < maxConditionNumbers[i]) {
maxConditionNumber = maxConditionNumbers[i];
maxConditionNumberOwner = i;
}
}
if (rank==maxConditionNumberOwner) { // owner is responsible for writing to file
// cout << "max condition number is on rank " << rank << endl;
if (sparseFileToWriteTo.length() > 0) {
if (maxConditionNumberIPMatrix.size() > 0) {
DataIO::writeMatrixToSparseDataFile(maxConditionNumberIPMatrix, sparseFileToWriteTo);
}
}
}
// cout << "max condition number occurs in cellID " << maxCellID << endl;
return maxConditionNumber;
}
void BilinearFormUtility<Scalar>::computeStiffnessMatrixForCell(FieldContainer<Scalar> &stiffness, Teuchos::RCP<Mesh> mesh, int cellID)
{
DofOrderingPtr trialOrder = mesh->getElementType(cellID)->trialOrderPtr;
DofOrderingPtr testOrder = mesh->getElementType(cellID)->testOrderPtr;
CellTopoPtr cellTopo = mesh->getElementType(cellID)->cellTopoPtr;
FieldContainer<double> physicalCellNodes = mesh->physicalCellNodesForCell(cellID);
FieldContainer<double> cellSideParities = mesh->cellSideParitiesForCell(cellID);
int numCells = 1;
stiffness.resize(numCells,testOrder->totalDofs(),trialOrder->totalDofs());
computeStiffnessMatrix(stiffness,mesh->bilinearForm(),trialOrder,testOrder,cellTopo,physicalCellNodes,cellSideParities);
}
// computes riesz representation over a single element - map is from int (testID) to FieldContainer of values (sized cellIndex, numPoints)
void RieszRep::computeRepresentationValues(FieldContainer<double> &values, int testID, IntrepidExtendedTypes::EOperatorExtended op, BasisCachePtr basisCache){
if (_repsNotComputed){
cout << "Computing riesz rep dofs" << endl;
computeRieszRep();
}
int spaceDim = _mesh->getTopology()->getSpaceDim();
int numCells = values.dimension(0);
int numPoints = values.dimension(1);
vector<GlobalIndexType> cellIDs = basisCache->cellIDs();
// all elems coming in should be of same type
ElementPtr elem = _mesh->getElement(cellIDs[0]);
ElementTypePtr elemTypePtr = elem->elementType();
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
CellTopoPtrLegacy cellTopoPtr = elemTypePtr->cellTopoPtr;
int numTestDofsForVarID = testOrderingPtr->getBasisCardinality(testID, 0);
BasisPtr testBasis = testOrderingPtr->getBasis(testID);
bool testBasisIsVolumeBasis = (spaceDim == testBasis->domainTopology()->getDimension());
bool useCubPointsSideRefCell = testBasisIsVolumeBasis && basisCache->isSideCache();
Teuchos::RCP< const FieldContainer<double> > transformedBasisValues = basisCache->getTransformedValues(testBasis,op,useCubPointsSideRefCell);
int rank = values.rank() - 2; // if values are shaped as (C,P), scalar...
if (rank > 1) {
cout << "ranks greater than 1 not presently supported...\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "ranks greater than 1 not presently supported...");
}
// Camellia::print("cellIDs",cellIDs);
values.initialize(0.0);
for (int cellIndex = 0;cellIndex<numCells;cellIndex++){
int cellID = cellIDs[cellIndex];
for (int j = 0;j<numTestDofsForVarID;j++) {
int dofIndex = testOrderingPtr->getDofIndex(testID, j);
for (int i = 0;i<numPoints;i++) {
if (rank==0) {
double basisValue = (*transformedBasisValues)(cellIndex,j,i);
values(cellIndex,i) += basisValue*_rieszRepDofsGlobal[cellID](dofIndex);
} else {
for (int d = 0; d<spaceDim; d++) {
double basisValue = (*transformedBasisValues)(cellIndex,j,i,d);
values(cellIndex,i,d) += basisValue*_rieszRepDofsGlobal[cellID](dofIndex);
}
}
}
}
}
// TestSuite::serializeOutput("rep values", values);
}
bool checkLTSumConsistency(LinearTermPtr a, LinearTermPtr b, DofOrderingPtr dofOrdering, BasisCachePtr basisCache)
{
double tol = 1e-14;
int numCells = basisCache->cellIDs().size();
int numDofs = dofOrdering->totalDofs();
bool forceBoundaryTerm = false;
FieldContainer<double> aValues(numCells,numDofs), bValues(numCells,numDofs), sumValues(numCells,numDofs);
a->integrate(aValues,dofOrdering,basisCache,forceBoundaryTerm);
b->integrate(bValues,dofOrdering,basisCache,forceBoundaryTerm);
(a+b)->integrate(sumValues, dofOrdering, basisCache, forceBoundaryTerm);
int size = aValues.size();
for (int i=0; i<size; i++)
{
double expectedValue = aValues[i] + bValues[i];
double diff = abs( expectedValue - sumValues[i] );
if (diff > tol)
{
return false;
}
}
return true;
}
map< int, vector<DofInfo> > constructGlobalDofToLocalDofInfoMap(MeshPtr mesh)
{
// go through the mesh as a whole, and collect info for each dof
map< int, vector<DofInfo> > infoMap;
DofInfo info;
set<GlobalIndexType> activeCellIDs = mesh->getActiveCellIDsGlobal();
for (set<GlobalIndexType>::iterator cellIt = activeCellIDs.begin(); cellIt != activeCellIDs.end(); cellIt++)
{
GlobalIndexType cellID = *cellIt;
info.cellID = cellID;
ElementPtr element = mesh->getElement(cellID);
DofOrderingPtr trialOrder = element->elementType()->trialOrderPtr;
set<int> trialIDs = trialOrder->getVarIDs();
info.totalDofs = trialOrder->totalDofs();
for (set<int>::iterator trialIt=trialIDs.begin(); trialIt != trialIDs.end(); trialIt++)
{
info.trialID = *trialIt;
const vector<int>* sidesForVar = &trialOrder->getSidesForVarID(info.trialID);
for (vector<int>::const_iterator sideIt = sidesForVar->begin(); sideIt != sidesForVar->end(); sideIt++)
{
int sideIndex = *sideIt;
info.sideIndex = sideIndex;
info.basisCardinality = trialOrder->getBasisCardinality(info.trialID, info.sideIndex);
for (int basisOrdinal=0; basisOrdinal < info.basisCardinality; basisOrdinal++)
{
info.basisOrdinal = basisOrdinal;
info.localDofIndex = trialOrder->getDofIndex(info.trialID, info.basisOrdinal, info.sideIndex);
pair<int, int> localDofIndexKey = make_pair(info.cellID, info.localDofIndex);
int globalDofIndex = mesh->getLocalToGlobalMap().find(localDofIndexKey)->second;
// cout << "(" << info.cellID << "," << info.localDofIndex << ") --> " << globalDofIndex << endl;
infoMap[globalDofIndex].push_back(info);
}
}
}
}
return infoMap;
}
bool FunctionTests::testValuesDottedWithTensor()
{
bool success = true;
vector< FunctionPtr > vectorFxns;
double xValue = 3, yValue = 4;
FunctionPtr simpleVector = Function::vectorize(Function::constant(xValue), Function::constant(yValue));
vectorFxns.push_back(simpleVector);
FunctionPtr x = Function::xn(1);
FunctionPtr y = Function::yn(1);
vectorFxns.push_back( Function::vectorize(x*x, x*y) );
VGPStokesFormulation vgpStokes = VGPStokesFormulation(1.0);
BFPtr bf = vgpStokes.bf();
int h1Order = 1;
MeshPtr mesh = MeshFactory::quadMesh(bf, h1Order);
int cellID=0; // the only cell
BasisCachePtr basisCache = BasisCache::basisCacheForCell(mesh, cellID);
for (int i=0; i<vectorFxns.size(); i++)
{
FunctionPtr vectorFxn_i = vectorFxns[i];
for (int j=0; j<vectorFxns.size(); j++)
{
FunctionPtr vectorFxn_j = vectorFxns[j];
FunctionPtr dotProduct = vectorFxn_i * vectorFxn_j;
FunctionPtr expectedDotProduct = vectorFxn_i->x() * vectorFxn_j->x() + vectorFxn_i->y() * vectorFxn_j->y();
if (! expectedDotProduct->equals(dotProduct, basisCache))
{
cout << "testValuesDottedWithTensor() failed: expected dot product does not match dotProduct.\n";
success = false;
double tol = 1e-14;
reportFunctionValueDifferences(dotProduct, expectedDotProduct, basisCache, tol);
}
}
}
// now, let's try the same thing, but for a LinearTerm dot product
VarFactoryPtr vf = VarFactory::varFactory();
VarPtr v = vf->testVar("v", HGRAD);
DofOrderingPtr dofOrdering = Teuchos::rcp( new DofOrdering(CellTopology::quad()) );
shards::CellTopology quad_4(shards::getCellTopologyData<shards::Quadrilateral<4> >() );
BasisPtr basis = BasisFactory::basisFactory()->getBasis(h1Order, quad_4.getKey(), Camellia::FUNCTION_SPACE_HGRAD);
dofOrdering->addEntry(v->ID(), basis, v->rank());
int numCells = 1;
int numFields = basis->getCardinality();
for (int i=0; i<vectorFxns.size(); i++)
{
FunctionPtr f_i = vectorFxns[i];
LinearTermPtr lt_i = f_i * v;
LinearTermPtr lt_i_x = f_i->x() * v;
LinearTermPtr lt_i_y = f_i->y() * v;
for (int j=0; j<vectorFxns.size(); j++)
{
FunctionPtr f_j = vectorFxns[j];
LinearTermPtr lt_j = f_j * v;
LinearTermPtr lt_j_x = f_j->x() * v;
LinearTermPtr lt_j_y = f_j->y() * v;
FieldContainer<double> values(numCells,numFields,numFields);
lt_i->integrate(values, dofOrdering, lt_j, dofOrdering, basisCache);
FieldContainer<double> values_expected(numCells,numFields,numFields);
lt_i_x->integrate(values_expected,dofOrdering,lt_j_x,dofOrdering,basisCache);
lt_i_y->integrate(values_expected,dofOrdering,lt_j_y,dofOrdering,basisCache);
double tol = 1e-14;
double maxDiff = 0;
if (!fcsAgree(values, values_expected, tol, maxDiff))
{
cout << "FunctionTests::testValuesDottedWithTensor: ";
cout << "dot product and sum of the products of scalar components differ by maxDiff " << maxDiff;
cout << " in LinearTerm::integrate().\n";
success = false;
}
}
}
// // finally, let's try the same sort of thing, but now with a vector-valued basis
// BasisPtr vectorBasisTemp = BasisFactory::basisFactory()->getBasis(h1Order, quad_4.getKey(), Camellia::FUNCTION_SPACE_VECTOR_HGRAD);
// VectorBasisPtr vectorBasis = Teuchos::rcp( (VectorizedBasis<double, FieldContainer<double> > *)vectorBasisTemp.get(),false);
//
// BasisPtr compBasis = vectorBasis->getComponentBasis();
//
// // create a new v, and a new dofOrdering
// VarPtr v_vector = vf->testVar("v_vector", VECTOR_HGRAD);
// dofOrdering = Teuchos::rcp( new DofOrdering );
// dofOrdering->addEntry(v_vector->ID(), vectorBasis, v_vector->rank());
//
// DofOrderingPtr dofOrderingComp = Teuchos::rcp( new DofOrdering );
// dofOrderingComp->addEntry(v->ID(), compBasis, v->rank());
//
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:
bool useTriangles = false;
FieldContainer<double> meshPoints(4,2);
meshPoints(0,0) = 0.0; // x1
meshPoints(0,1) = 0.0; // y1
meshPoints(1,0) = 1.0;
meshPoints(1,1) = 0.0;
meshPoints(2,0) = 1.0;
meshPoints(2,1) = 1.0;
meshPoints(3,0) = 0.0;
meshPoints(3,1) = 1.0;
int H1Order = polyOrder + 1;
int horizontalCells = 4, verticalCells = 4;
double energyThreshold = 0.2; // for mesh refinements
double nonlinearStepSize = 0.5;
double nonlinearRelativeEnergyTolerance = 1e-8; // used to determine convergence of the nonlinear solution
////////////////////////////////////////////////////////////////////
// DEFINE VARIABLES
////////////////////////////////////////////////////////////////////
// new-style bilinear form definition
VarFactory varFactory;
VarPtr fhat = varFactory.fluxVar("\\widehat{f}");
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 = Mesh::buildQuadMesh(meshPoints, horizontalCells,
verticalCells, bf, H1Order,
H1Order+pToAdd, useTriangles);
mesh->setPartitionPolicy(Teuchos::rcp(new ZoltanMeshPartitionPolicy("HSFC")));
////////////////////////////////////////////////////////////////////
// INITIALIZE BACKGROUND FLOW FUNCTIONS
////////////////////////////////////////////////////////////////////
BCPtr nullBC = Teuchos::rcp((BC*)NULL);
RHSPtr nullRHS = Teuchos::rcp((RHS*)NULL);
IPPtr nullIP = Teuchos::rcp((IP*)NULL);
SolutionPtr backgroundFlow = Teuchos::rcp(new Solution(mesh, nullBC,
nullRHS, nullIP) );
vector<double> e1(2); // (1,0)
e1[0] = 1;
vector<double> e2(2); // (0,1)
e2[1] = 1;
FunctionPtr u_prev = Teuchos::rcp( new PreviousSolutionFunction(backgroundFlow, u) );
FunctionPtr beta = e1 * u_prev + Teuchos::rcp( new ConstantVectorFunction( e2 ) );
////////////////////////////////////////////////////////////////////
// DEFINE BILINEAR FORM
////////////////////////////////////////////////////////////////////
// v:
// (sigma, grad v)_K - (sigma_hat_n, v)_dK - (u, beta dot grad v) + (u_hat * n dot beta, v)_dK
bf->addTerm( -u, beta * v->grad());
bf->addTerm( fhat, v);
// ==================== SET INITIAL GUESS ==========================
mesh->registerSolution(backgroundFlow);
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
FunctionPtr u0 = Teuchos::rcp( new U0 );
map<int, Teuchos::RCP<Function> > functionMap;
functionMap[u->ID()] = u0;
backgroundFlow->projectOntoMesh(functionMap);
// ==================== END SET INITIAL GUESS ==========================
////////////////////////////////////////////////////////////////////
// DEFINE INNER PRODUCT
////////////////////////////////////////////////////////////////////
IPPtr ip = Teuchos::rcp( new IP );
ip->addTerm( v );
ip->addTerm( beta * v->grad() );
////////////////////////////////////////////////////////////////////
// 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());
////////////////////////////////////////////////////////////////////
// DEFINE DIRICHLET BC
////////////////////////////////////////////////////////////////////
Teuchos::RCP<BCEasy> inflowBC = Teuchos::rcp( new BCEasy );
// Create spatial filters
SpatialFilterPtr bottomBoundary = Teuchos::rcp( new BottomBoundary );
SpatialFilterPtr leftBoundary = Teuchos::rcp( new LeftBoundary );
SpatialFilterPtr rightBoundary = Teuchos::rcp( new LeftBoundary );
// Create BCs
FunctionPtr n = Teuchos::rcp( new UnitNormalFunction );
FunctionPtr u0_squared_div_2 = 0.5 * u0 * u0;
SimpleFunction* u0Ptr = static_cast<SimpleFunction *>(u0.get());
double u0Left = u0Ptr->value(0,0);
double u0Right = u0Ptr->value(1.0,0);
FunctionPtr leftVal = Teuchos::rcp( new ConstantScalarFunction( -0.5*u0Left*u0Left ) );
FunctionPtr rightVal = Teuchos::rcp( new ConstantScalarFunction( 0.5*u0Right*u0Right ) );
inflowBC->addDirichlet(fhat, bottomBoundary, -u0 );
inflowBC->addDirichlet(fhat, leftBoundary, leftVal );
inflowBC->addDirichlet(fhat, rightBoundary, rightVal );
////////////////////////////////////////////////////////////////////
// CREATE SOLUTION OBJECT
////////////////////////////////////////////////////////////////////
Teuchos::RCP<Solution> solution = Teuchos::rcp(new Solution(mesh, inflowBC, rhs, ip));
mesh->registerSolution(solution);
if (enforceLocalConservation)
{
FunctionPtr zero = Teuchos::rcp( new ConstantScalarFunction(0.0) );
solution->lagrangeConstraints()->addConstraint(fhat == zero);
}
////////////////////////////////////////////////////////////////////
// DEFINE REFINEMENT STRATEGY
////////////////////////////////////////////////////////////////////
Teuchos::RCP<RefinementStrategy> refinementStrategy;
refinementStrategy = Teuchos::rcp(new RefinementStrategy(solution,energyThreshold));
////////////////////////////////////////////////////////////////////
// SOLVE
////////////////////////////////////////////////////////////////////
for (int refIndex=0; refIndex<=numRefs; refIndex++)
{
double L2Update = 1e7;
int iterCount = 0;
while (L2Update > nonlinearRelativeEnergyTolerance && iterCount < maxNewtonIterations)
{
solution->solve();
L2Update = solution->L2NormOfSolutionGlobal(u->ID());
cout << "L2 Norm of Update = " << L2Update << endl;
// backgroundFlow->clear();
backgroundFlow->addSolution(solution, newtonStepSize);
iterCount++;
}
cout << endl;
// check conservation
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 massFlux = Teuchos::rcp( new PreviousSolutionFunction(solution, fhat) );
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] );
}
}
if (rank==0)
{
cout << endl;
cout << "largest mass flux: " << maxMassFluxIntegral << endl;
cout << "total mass flux: " << totalMassFlux << endl;
cout << "sum of mass flux absolute value: " << totalAbsMassFlux << endl;
cout << endl;
stringstream outfile;
outfile << "burgers_" << refIndex;
backgroundFlow->writeToVTK(outfile.str(), 5);
}
if (refIndex < numRefs)
refinementStrategy->refine(rank==0); // print to console on rank 0
}
return 0;
}
void PenaltyMethodFilter::filter(FieldContainer<double> &localStiffnessMatrix, FieldContainer<double> &localRHSVector,
BasisCachePtr basisCache, Teuchos::RCP<Mesh> mesh, Teuchos::RCP<BC> bc){
// assumption: filter gets elements of all the same type
TEUCHOS_TEST_FOR_EXCEPTION(basisCache->cellIDs().size()==0,std::invalid_argument,"no cell IDs given to filter");
ElementTypePtr elemTypePtr = mesh->getElement(basisCache->cellIDs()[0])->elementType();
int numCells = localStiffnessMatrix.dimension(0);
DofOrderingPtr trialOrderPtr = elemTypePtr->trialOrderPtr;
unsigned numSides = CamelliaCellTools::getSideCount( *elemTypePtr->cellTopoPtr );
// only allows for L2 inner products at the moment.
IntrepidExtendedTypes::EOperatorExtended trialOperator = IntrepidExtendedTypes::OP_VALUE;
// loop over sides first
for (unsigned int sideIndex = 0; sideIndex<numSides; sideIndex++){
// GET INTEGRATION INFO - get cubature points and side normals to send to Constraints (Cell,Point, spaceDim)
FieldContainer<double> sideCubPoints = basisCache->getPhysicalCubaturePointsForSide(sideIndex);
FieldContainer<double> sideNormals = basisCache->getSideUnitNormals(sideIndex);
int numPts = sideCubPoints.dimension(1);
// GET CONSTRAINT INFO
vector<map<int, FieldContainer<double> > > constrCoeffsVector;
vector<FieldContainer<double> > constraintValuesVector;
vector<FieldContainer<bool> > imposeHereVector;
_constraints->getConstraints(sideCubPoints,sideNormals,constrCoeffsVector,constraintValuesVector);
//loop thru constraints
int i = 0;
for (vector<map<int,FieldContainer<double> > >::iterator constrIt = constrCoeffsVector.begin();
constrIt !=constrCoeffsVector.end(); constrIt++) {
map<int,FieldContainer<double> > constrCoeffs = *constrIt;
FieldContainer<double> constrValues = constraintValuesVector[i];
i++;
double penaltyParameter = 1e7; // (single_precision)^(-1) - perhaps have this computed relative to terms in the matrix?
for (map<int,FieldContainer<double> >::iterator constrTestIDIt = constrCoeffs.begin();
constrTestIDIt !=constrCoeffs.end(); constrTestIDIt++) {
pair<int,FieldContainer<double> > constrTestPair = *constrTestIDIt;
int testTrialID = constrTestPair.first;
// get basis to integrate for testing fxns
BasisPtr testTrialBasis = trialOrderPtr->getBasis(testTrialID,sideIndex);
FieldContainer<double> testTrialValuesTransformedWeighted = *(basisCache->getTransformedWeightedValues(testTrialBasis,trialOperator,
sideIndex,false));
// make copies b/c we can't fudge with return values from basisCache (const) - dimensions (Cell,Field - basis ordinal, Point)
FieldContainer<double> testTrialValuesWeightedCopy = testTrialValuesTransformedWeighted;
int numDofs2 = trialOrderPtr->getBasisCardinality(testTrialID,sideIndex);
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
for (int dofIndex=0; dofIndex<numDofs2; dofIndex++){
for (int ptIndex=0; ptIndex<numPts; ptIndex++){
testTrialValuesWeightedCopy(cellIndex, dofIndex, ptIndex) *= constrTestPair.second(cellIndex, ptIndex); // scale by constraint coeff
}
}
}
// loop thru pairs of trialIDs and constr coeffs
for (map<int,FieldContainer<double> >::iterator constrIDIt = constrCoeffs.begin();
constrIDIt !=constrCoeffs.end(); constrIDIt++) {
pair<int,FieldContainer<double> > constrPair = *constrIDIt;
int trialID = constrPair.first;
// get basis to integrate
BasisPtr trialBasis1 = trialOrderPtr->getBasis(trialID,sideIndex);
// for trial: the value lives on the side, so we don't use the volume coords either:
FieldContainer<double> trialValuesTransformed = *(basisCache->getTransformedValues(trialBasis1,trialOperator,sideIndex,false));
// make copies b/c we can't fudge with return values from basisCache (const) - dimensions (Cell,Field - basis ordinal, Point)
FieldContainer<double> trialValuesCopy = trialValuesTransformed;
// transform trial values
int numDofs1 = trialOrderPtr->getBasisCardinality(trialID,sideIndex);
for (int dofIndex=0; dofIndex<numDofs1; dofIndex++){
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
for (int ptIndex=0; ptIndex<numPts; ptIndex++){
trialValuesCopy(cellIndex, dofIndex, ptIndex) *= constrPair.second(cellIndex, ptIndex); // scale by constraint coeff
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// integrate the transformed values, add them to the relevant trial/testTrialID dof combos
FieldContainer<double> unweightedPenaltyMatrix(numCells,numDofs1,numDofs2);
FunctionSpaceTools::integrate<double>(unweightedPenaltyMatrix,trialValuesCopy,testTrialValuesWeightedCopy,COMP_BLAS);
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
for (int testDofIndex=0; testDofIndex<numDofs2; testDofIndex++){
int localTestDof = trialOrderPtr->getDofIndex(testTrialID, testDofIndex, sideIndex);
for (int trialDofIndex=0; trialDofIndex<numDofs1; trialDofIndex++){
int localTrialDof = trialOrderPtr->getDofIndex(trialID, trialDofIndex, sideIndex);
localStiffnessMatrix(cellIndex,localTrialDof,localTestDof)
+= penaltyParameter*unweightedPenaltyMatrix(cellIndex,trialDofIndex,testDofIndex);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// set penalty load
FieldContainer<double> unweightedRHSVector(numCells,numDofs2);
FunctionSpaceTools::integrate<double>(unweightedRHSVector,constrValues,testTrialValuesWeightedCopy,COMP_BLAS);
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
for (int testDofIndex=0; testDofIndex<numDofs2; testDofIndex++){
int localTestDof = trialOrderPtr->getDofIndex(testTrialID, testDofIndex, sideIndex);
localRHSVector(cellIndex,localTestDof) += penaltyParameter*unweightedRHSVector(cellIndex,testDofIndex);
}
}
}
}
}
}
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;
}
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);
}
}
}
}
}
void RieszRep::distributeDofs(){
int myRank = Teuchos::GlobalMPISession::getRank();
int numRanks = Teuchos::GlobalMPISession::getNProc();
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
//cout << "rank: " << rank << " of " << numProcs << endl;
#else
Epetra_SerialComm Comm;
#endif
// the code below could stand to be reworked; I'm pretty sure this is not the best way to distribute the data, and it would also be best to get rid of the iteration over the global set of active elements. But a similar point could be made about this method as a whole: do we really need to distribute all the dofs to every rank? It may be best to eliminate this method altogether.
vector<GlobalIndexType> cellIDsByPartitionOrdering;
for (int rank=0; rank<numRanks; rank++) {
set<GlobalIndexType> cellIDsForRank = _mesh->globalDofAssignment()->cellsInPartition(rank);
cellIDsByPartitionOrdering.insert(cellIDsByPartitionOrdering.end(), cellIDsForRank.begin(), cellIDsForRank.end());
}
// determine inverse map:
map<GlobalIndexType,int> ordinalForCellID;
for (int ordinal=0; ordinal<cellIDsByPartitionOrdering.size(); ordinal++) {
GlobalIndexType cellID = cellIDsByPartitionOrdering[ordinal];
ordinalForCellID[cellID] = ordinal;
// cout << "ordinalForCellID[" << cellID << "] = " << ordinal << endl;
}
for (int cellOrdinal=0; cellOrdinal<cellIDsByPartitionOrdering.size(); cellOrdinal++) {
GlobalIndexType cellID = cellIDsByPartitionOrdering[cellOrdinal];
ElementTypePtr elemTypePtr = _mesh->getElementType(cellID);
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
int numDofs = testOrderingPtr->totalDofs();
int cellIDPartition = _mesh->partitionForCellID(cellID);
bool isInPartition = (cellIDPartition == myRank);
int numMyDofs;
FieldContainer<double> dofs(numDofs);
if (isInPartition){ // if in partition
numMyDofs = numDofs;
dofs = _rieszRepDofs[cellID];
} else{
numMyDofs = 0;
}
Epetra_Map dofMap(numDofs,numMyDofs,0,Comm);
Epetra_Vector distributedRieszDofs(dofMap);
if (isInPartition) {
for (int i = 0;i<numMyDofs;i++) { // shouldn't activate on off-proc partitions
distributedRieszDofs.ReplaceGlobalValues(1,&dofs(i),&i);
}
}
Epetra_Map importMap(numDofs,numDofs,0,Comm); // every proc should own their own copy of the dofs
Epetra_Import testDofImporter(importMap, dofMap);
Epetra_Vector globalRieszDofs(importMap);
globalRieszDofs.Import(distributedRieszDofs, testDofImporter, Insert);
if (!isInPartition){
for (int i = 0;i<numDofs;i++){
dofs(i) = globalRieszDofs[i];
}
}
_rieszRepDofsGlobal[cellID] = dofs;
// { // debugging
// ostringstream cellIDlabel;
// cellIDlabel << "cell " << cellID << " _rieszRepDofsGlobal, after global import";
// TestSuite::serializeOutput(cellIDlabel.str(), _rieszRepDofsGlobal[cellID]);
// }
}
// distribute norms as well
GlobalIndexType numElems = _mesh->numActiveElements();
set<GlobalIndexType> rankLocalCellIDs = _mesh->cellIDsInPartition();
IndexType numMyElems = rankLocalCellIDs.size();
GlobalIndexType myElems[numMyElems];
// build cell index
GlobalIndexType myCellOrdinal = 0;
double rankLocalRieszNorms[numMyElems];
for (set<GlobalIndexType>::iterator cellIDIt = rankLocalCellIDs.begin(); cellIDIt != rankLocalCellIDs.end(); cellIDIt++) {
GlobalIndexType cellID = *cellIDIt;
myElems[myCellOrdinal] = ordinalForCellID[cellID];
rankLocalRieszNorms[myCellOrdinal] = _rieszRepNormSquared[cellID];
myCellOrdinal++;
}
Epetra_Map normMap((GlobalIndexTypeToCast)numElems,(int)numMyElems,(GlobalIndexTypeToCast *)myElems,(GlobalIndexTypeToCast)0,Comm);
Epetra_Vector distributedRieszNorms(normMap);
int err = distributedRieszNorms.ReplaceGlobalValues(numMyElems,rankLocalRieszNorms,(GlobalIndexTypeToCast *)myElems);
if (err != 0) {
cout << "RieszRep::distributeDofs(): on rank" << myRank << ", ReplaceGlobalValues returned error code " << err << endl;
}
Epetra_Map normImportMap((GlobalIndexTypeToCast)numElems,(GlobalIndexTypeToCast)numElems,0,Comm);
Epetra_Import normImporter(normImportMap,normMap);
Epetra_Vector globalNorms(normImportMap);
globalNorms.Import(distributedRieszNorms, normImporter, Add); // add should be OK (everything should be zeros)
for (int cellOrdinal=0; cellOrdinal<cellIDsByPartitionOrdering.size(); cellOrdinal++) {
GlobalIndexType cellID = cellIDsByPartitionOrdering[cellOrdinal];
_rieszRepNormSquaredGlobal[cellID] = globalNorms[cellOrdinal];
// if (myRank==0) cout << "_rieszRepNormSquaredGlobal[" << cellID << "] = " << globalNorms[cellOrdinal] << endl;
}
}
bool MeshTestUtility::neighborBasesAgreeOnSides(Teuchos::RCP<Mesh> mesh, Epetra_MultiVector &globalSolutionCoefficients)
{
bool success = true;
MeshTopologyViewPtr meshTopo = mesh->getTopology();
int spaceDim = meshTopo->getDimension();
set<IndexType> activeCellIndices = meshTopo->getActiveCellIndices();
for (set<IndexType>::iterator cellIt=activeCellIndices.begin(); cellIt != activeCellIndices.end(); cellIt++)
{
IndexType cellIndex = *cellIt;
CellPtr cell = meshTopo->getCell(cellIndex);
BasisCachePtr fineCellBasisCache = BasisCache::basisCacheForCell(mesh, cellIndex);
ElementTypePtr fineElemType = mesh->getElementType(cellIndex);
DofOrderingPtr fineElemTrialOrder = fineElemType->trialOrderPtr;
FieldContainer<double> fineSolutionCoefficients(fineElemTrialOrder->totalDofs());
mesh->globalDofAssignment()->interpretGlobalCoefficients(cellIndex, fineSolutionCoefficients, globalSolutionCoefficients);
// if ((cellIndex==0) || (cellIndex==2)) {
// cout << "MeshTestUtility: local coefficients for cell " << cellIndex << ":\n" << fineSolutionCoefficients;
// }
unsigned sideCount = cell->getSideCount();
for (unsigned sideOrdinal=0; sideOrdinal<sideCount; sideOrdinal++)
{
FieldContainer<double> fineSideRefPoints, fineCellRefPoints, coarseSideRefPoints, coarseCellRefPoints;
bool hasCoarserNeighbor = determineRefTestPointsForNeighbors(meshTopo, cell, sideOrdinal, fineSideRefPoints, fineCellRefPoints, coarseSideRefPoints, coarseCellRefPoints);
if (!hasCoarserNeighbor) continue;
pair<GlobalIndexType, unsigned> neighborInfo = cell->getNeighborInfo(sideOrdinal, meshTopo);
CellPtr neighborCell = meshTopo->getCell(neighborInfo.first);
unsigned numTestPoints = coarseCellRefPoints.dimension(0);
// cout << "testing neighbor agreement between cell " << cellIndex << " and " << neighborCell->cellIndex() << endl;
// if we get here, the cell has a neighbor on this side, and is at least as fine as that neighbor.
BasisCachePtr fineSideBasisCache = fineCellBasisCache->getSideBasisCache(sideOrdinal);
fineCellBasisCache->setRefCellPoints(fineCellRefPoints);
BasisCachePtr coarseCellBasisCache = BasisCache::basisCacheForCell(mesh, neighborInfo.first);
BasisCachePtr coarseSideBasisCache = coarseCellBasisCache->getSideBasisCache(neighborInfo.second);
coarseCellBasisCache->setRefCellPoints(coarseCellRefPoints);
bool hasSidePoints = (fineSideRefPoints.size() > 0);
if (hasSidePoints)
{
fineSideBasisCache->setRefCellPoints(fineSideRefPoints);
coarseSideBasisCache->setRefCellPoints(coarseSideRefPoints);
}
// sanity check: do physical points match?
FieldContainer<double> fineCellPhysicalCubaturePoints = fineCellBasisCache->getPhysicalCubaturePoints();
FieldContainer<double> coarseCellPhysicalCubaturePoints = coarseCellBasisCache->getPhysicalCubaturePoints();
double tol = 1e-14;
double maxDiff = 0;
if (! fcsAgree(coarseCellPhysicalCubaturePoints, fineCellPhysicalCubaturePoints, tol, maxDiff) )
{
cout << "ERROR: MeshTestUtility::neighborBasesAgreeOnSides internal error: fine and coarse cell cubature points do not agree.\n";
success = false;
continue;
}
if (hasSidePoints)
{
FieldContainer<double> fineSidePhysicalCubaturePoints = fineSideBasisCache->getPhysicalCubaturePoints();
FieldContainer<double> coarseSidePhysicalCubaturePoints = coarseSideBasisCache->getPhysicalCubaturePoints();
double tol = 1e-14;
double maxDiff = 0;
if (! fcsAgree(fineSidePhysicalCubaturePoints, fineCellPhysicalCubaturePoints, tol, maxDiff) )
{
cout << "ERROR: MeshTestUtility::neighborBasesAgreeOnSides internal error: fine side and cell cubature points do not agree.\n";
success = false;
continue;
}
if (! fcsAgree(coarseSidePhysicalCubaturePoints, coarseCellPhysicalCubaturePoints, tol, maxDiff) )
{
cout << "ERROR: MeshTestUtility::neighborBasesAgreeOnSides internal error: coarse side and cell cubature points do not agree.\n";
success = false;
continue;
}
if (! fcsAgree(coarseSidePhysicalCubaturePoints, fineSidePhysicalCubaturePoints, tol, maxDiff) )
{
cout << "ERROR: MeshTestUtility::neighborBasesAgreeOnSides internal error: fine and coarse side cubature points do not agree.\n";
success = false;
continue;
}
}
ElementTypePtr coarseElementType = mesh->getElementType(neighborInfo.first);
DofOrderingPtr coarseElemTrialOrder = coarseElementType->trialOrderPtr;
FieldContainer<double> coarseSolutionCoefficients(coarseElemTrialOrder->totalDofs());
mesh->globalDofAssignment()->interpretGlobalCoefficients(neighborInfo.first, coarseSolutionCoefficients, globalSolutionCoefficients);
set<int> varIDs = fineElemTrialOrder->getVarIDs();
for (set<int>::iterator varIt = varIDs.begin(); varIt != varIDs.end(); varIt++)
{
int varID = *varIt;
// cout << "MeshTestUtility: varID " << varID << ":\n";
bool isTraceVar = mesh->bilinearForm()->isFluxOrTrace(varID);
BasisPtr fineBasis, coarseBasis;
BasisCachePtr fineCache, coarseCache;
if (isTraceVar)
{
if (! hasSidePoints) continue; // then nothing to do for traces
fineBasis = fineElemTrialOrder->getBasis(varID, sideOrdinal);
coarseBasis = coarseElemTrialOrder->getBasis(varID, neighborInfo.second);
fineCache = fineSideBasisCache;
coarseCache = coarseSideBasisCache;
}
else
{
fineBasis = fineElemTrialOrder->getBasis(varID);
coarseBasis = coarseElemTrialOrder->getBasis(varID);
fineCache = fineCellBasisCache;
coarseCache = coarseCellBasisCache;
Camellia::EFunctionSpace fs = fineBasis->functionSpace();
if ((fs == Camellia::FUNCTION_SPACE_HVOL)
|| (fs == Camellia::FUNCTION_SPACE_VECTOR_HVOL)
|| (fs == Camellia::FUNCTION_SPACE_TENSOR_HVOL))
{
// volume L^2 basis: no continuities expected...
continue;
}
}
FieldContainer<double> localValuesFine = *fineCache->getTransformedValues(fineBasis, OP_VALUE);
FieldContainer<double> localValuesCoarse = *coarseCache->getTransformedValues(coarseBasis, OP_VALUE);
bool scalarValued = (localValuesFine.rank() == 3);
// the following used if vector or tensor-valued:
Teuchos::Array<int> valueDim;
unsigned componentsPerValue = 1;
FieldContainer<double> valueContainer; // just used for enumeration computation...
if (!scalarValued)
{
localValuesFine.dimensions(valueDim);
// clear first three:
valueDim.erase(valueDim.begin());
valueDim.erase(valueDim.begin());
valueDim.erase(valueDim.begin());
valueContainer.resize(valueDim);
componentsPerValue = valueContainer.size();
}
// if (localValuesFine.rank() != 3) {
// cout << "WARNING: MeshTestUtility::neighborBasesAgreeOnSides() only supports scalar-valued bases right now. Skipping check for varID " << varID << endl;
// continue;
// }
FieldContainer<double> localPointValuesFine(fineElemTrialOrder->totalDofs());
FieldContainer<double> localPointValuesCoarse(coarseElemTrialOrder->totalDofs());
for (int valueComponentOrdinal=0; valueComponentOrdinal<componentsPerValue; valueComponentOrdinal++)
{
Teuchos::Array<int> valueMultiIndex(valueContainer.rank());
if (!scalarValued)
valueContainer.getMultiIndex(valueMultiIndex, valueComponentOrdinal);
Teuchos::Array<int> localValuesMultiIndex(localValuesFine.rank());
for (int r=0; r<valueMultiIndex.size(); r++)
{
localValuesMultiIndex[r+3] = valueMultiIndex[r];
}
for (int ptOrdinal=0; ptOrdinal<numTestPoints; ptOrdinal++)
{
localPointValuesCoarse.initialize(0);
localPointValuesFine.initialize(0);
localValuesMultiIndex[2] = ptOrdinal;
double fineSolutionValue = 0, coarseSolutionValue = 0;
for (int basisOrdinal=0; basisOrdinal < fineBasis->getCardinality(); basisOrdinal++)
{
int fineDofIndex;
if (isTraceVar)
fineDofIndex = fineElemTrialOrder->getDofIndex(varID, basisOrdinal, sideOrdinal);
else
fineDofIndex = fineElemTrialOrder->getDofIndex(varID, basisOrdinal);
if (scalarValued)
{
localPointValuesFine(fineDofIndex) = localValuesFine(0,basisOrdinal,ptOrdinal);
}
else
{
localValuesMultiIndex[1] = basisOrdinal;
localPointValuesFine(fineDofIndex) = localValuesFine.getValue(localValuesMultiIndex);
}
fineSolutionValue += fineSolutionCoefficients(fineDofIndex) * localPointValuesFine(fineDofIndex);
}
for (int basisOrdinal=0; basisOrdinal < coarseBasis->getCardinality(); basisOrdinal++)
{
int coarseDofIndex;
if (isTraceVar)
coarseDofIndex = coarseElemTrialOrder->getDofIndex(varID, basisOrdinal, neighborInfo.second);
else
coarseDofIndex = coarseElemTrialOrder->getDofIndex(varID, basisOrdinal);
if (scalarValued)
{
localPointValuesCoarse(coarseDofIndex) = localValuesCoarse(0,basisOrdinal,ptOrdinal);
}
else
{
localValuesMultiIndex[1] = basisOrdinal;
localPointValuesCoarse(coarseDofIndex) = localValuesCoarse.getValue(localValuesMultiIndex);
}
coarseSolutionValue += coarseSolutionCoefficients(coarseDofIndex) * localPointValuesCoarse(coarseDofIndex);
}
if (abs(coarseSolutionValue - fineSolutionValue) > 1e-13)
{
success = false;
cout << "coarseSolutionValue (" << coarseSolutionValue << ") and fineSolutionValue (" << fineSolutionValue << ") differ by " << abs(coarseSolutionValue - fineSolutionValue);
cout << " at point " << ptOrdinal << " for varID " << varID << ". ";
cout << "This may be an indication that something is amiss with the global-to-local map.\n";
}
else
{
// // DEBUGGING:
// cout << "solution value at point (";
// for (int d=0; d<spaceDim-1; d++) {
// cout << fineSidePhysicalCubaturePoints(0,ptOrdinal,d) << ", ";
// }
// cout << fineSidePhysicalCubaturePoints(0,ptOrdinal,spaceDim-1) << "): ";
// cout << coarseSolutionValue << endl;
}
FieldContainer<double> globalValuesFromFine, globalValuesFromCoarse;
FieldContainer<GlobalIndexType> globalDofIndicesFromFine, globalDofIndicesFromCoarse;
mesh->globalDofAssignment()->interpretLocalData(cellIndex, localPointValuesFine, globalValuesFromFine, globalDofIndicesFromFine);
mesh->globalDofAssignment()->interpretLocalData(neighborInfo.first, localPointValuesCoarse, globalValuesFromCoarse, globalDofIndicesFromCoarse);
std::map<GlobalIndexType, double> fineValuesMap;
std::map<GlobalIndexType, double> coarseValuesMap;
for (int i=0; i<globalDofIndicesFromCoarse.size(); i++)
{
GlobalIndexType globalDofIndex = globalDofIndicesFromCoarse[i];
coarseValuesMap[globalDofIndex] = globalValuesFromCoarse[i];
}
double maxDiff = 0;
for (int i=0; i<globalDofIndicesFromFine.size(); i++)
{
GlobalIndexType globalDofIndex = globalDofIndicesFromFine[i];
fineValuesMap[globalDofIndex] = globalValuesFromFine[i];
double diff = abs( fineValuesMap[globalDofIndex] - coarseValuesMap[globalDofIndex]);
maxDiff = std::max(diff, maxDiff);
if (diff > tol)
{
success = false;
cout << "interpreted fine and coarse disagree at point (";
for (int d=0; d<spaceDim; d++)
{
cout << fineCellPhysicalCubaturePoints(0,ptOrdinal,d);
if (d==spaceDim-1)
cout << ").\n";
else
cout << ", ";
}
}
}
if (maxDiff > tol)
{
cout << "maxDiff: " << maxDiff << endl;
cout << "globalValuesFromFine:\n" << globalValuesFromFine;
cout << "globalValuesFromCoarse:\n" << globalValuesFromCoarse;
cout << "globalDofIndicesFromFine:\n" << globalDofIndicesFromFine;
cout << "globalDofIndicesFromCoarse:\n" << globalDofIndicesFromCoarse;
continue; // only worth testing further if we passed the above
}
}
}
}
}
}
// cout << "Completed neighborBasesAgreeOnSides.\n";
return success;
}
bool MeshTestUtility::checkLocalGlobalConsistency(MeshPtr mesh, double tol)
{
bool success = true;
set<GlobalIndexType> cellIDs = mesh->getActiveCellIDs();
GlobalDofAssignmentPtr gda = mesh->globalDofAssignment();
// TODO: make this only check the locally-owned cells (right now does the whole mesh on every rank)
int numGlobalDofs = gda->globalDofCount();
FieldContainer<double> globalCoefficients(numGlobalDofs);
for (int i=0; i<numGlobalDofs; i++)
{
globalCoefficients(i) = 2*i + 1; // arbitrary cofficients
}
FieldContainer<double> globalCoefficientsExpected = globalCoefficients;
FieldContainer<double> globalCoefficientsActual(numGlobalDofs);
FieldContainer<double> localCoefficients;
Epetra_SerialComm Comm;
Epetra_BlockMap map(numGlobalDofs, 1, 0, Comm);
Epetra_Vector globalCoefficientsVector(map);
for (int i=0; i<numGlobalDofs; i++)
{
globalCoefficientsVector[i] = globalCoefficients(i);
}
cellIDs = mesh->getActiveCellIDs();
for (set<GlobalIndexType>::iterator cellIDIt = cellIDs.begin(); cellIDIt != cellIDs.end(); cellIDIt++)
{
GlobalIndexType cellID = *cellIDIt;
gda->interpretGlobalCoefficients(cellID, localCoefficients, globalCoefficientsVector);
FieldContainer<GlobalIndexType> globalDofIndices;
FieldContainer<double> globalCoefficientsForCell;
DofOrderingPtr trialOrder = mesh->getElementType(cellID)->trialOrderPtr;
set<int> varIDs = trialOrder->getVarIDs();
for (set<int>::iterator varIt=varIDs.begin(); varIt != varIDs.end(); varIt++)
{
int varID = *varIt;
const vector<int>* sidesForVar = &trialOrder->getSidesForVarID(varID);
for (vector<int>::const_iterator sideIt = sidesForVar->begin(); sideIt != sidesForVar->end(); sideIt++)
{
int sideOrdinal = *sideIt;
BasisPtr basis;
if (sidesForVar->size() == 1)
{
basis = trialOrder->getBasis(varID);
}
else
{
basis = trialOrder->getBasis(varID,sideOrdinal);
}
FieldContainer<double> basisCoefficients(basis->getCardinality());
for (int dofOrdinal=0; dofOrdinal<basis->getCardinality(); dofOrdinal++)
{
int localDofIndex;
if (sidesForVar->size() == 1)
{
localDofIndex = trialOrder->getDofIndex(varID, dofOrdinal);
}
else
{
localDofIndex = trialOrder->getDofIndex(varID, dofOrdinal, sideOrdinal);
}
basisCoefficients(dofOrdinal) = localCoefficients(localDofIndex);
}
gda->interpretLocalBasisCoefficients(cellID, varID, sideOrdinal,
basisCoefficients, globalCoefficientsForCell, globalDofIndices);
// if ( (cellID==2) && (sideOrdinal==1) && (varID==0) ) {
// cout << "DEBUGGING: (cellID==2) && (sideOrdinal==1).\n";
// cout << "globalDofIndices:\n" << globalDofIndices;
// cout << "globalCoefficientsForCell:\n" << globalCoefficientsForCell;
// cout << "basisCoefficients:\n" << basisCoefficients;
// }
for (int dofOrdinal=0; dofOrdinal < globalDofIndices.size(); dofOrdinal++)
{
GlobalIndexType dofIndex = globalDofIndices(dofOrdinal);
globalCoefficientsActual(dofIndex) = globalCoefficientsForCell(dofOrdinal);
double diff = abs(globalCoefficientsForCell(dofOrdinal) - globalCoefficientsExpected(dofIndex)) / globalCoefficientsExpected(dofIndex);
if (diff > tol)
{
cout << "In mapping for cell " << cellID << " and var " << varID << " on side " << sideOrdinal << ", ";
cout << "expected coefficient for global dof index " << dofIndex << " to be " << globalCoefficientsExpected(dofIndex);
cout << ", but was " << globalCoefficientsForCell(dofOrdinal);
cout << " (relative diff = " << diff << "; tol = " << tol << ")\n";
success = false;
}
}
}
}
}
// double maxDiff;
// if (TestSuite::fcsAgree(globalCoefficientsActual, globalCoefficientsExpected, tol, maxDiff)) {
// // cout << "global data actual and expected AGREE; max difference is " << maxDiff << endl;
// // cout << "globalCoefficientsActual:\n" << globalCoefficientsActual;
// } else {
// cout << "global data actual and expected DISAGREE; max difference is " << maxDiff << endl;
// success = false;
// cout << "Expected:\n" << globalCoefficientsExpected;
// cout << "Actual:\n" << globalCoefficientsActual;
// }
return success;
}
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;
}
void Projector::projectFunctionOntoBasis(FieldContainer<double> &basisCoefficients, Teuchos::RCP<AbstractFunction> fxn, BasisPtr basis,
const FieldContainer<double> &physicalCellNodes) {
CellTopoPtr cellTopo = basis->domainTopology();
DofOrderingPtr dofOrderPtr = Teuchos::rcp(new DofOrdering());
int basisRank = BasisFactory::basisFactory()->getBasisRank(basis);
int ID = 0; // only one entry for this fake dofOrderPtr
dofOrderPtr->addEntry(ID,basis,basisRank);
int maxTrialDegree = dofOrderPtr->maxBasisDegree();
// do not build side caches - no projections for sides supported at the moment
if (cellTopo->getTensorialDegree() != 0) {
cout << "Projector::projectFunctionOntoBasis() does not yet support tensorial degree > 0.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Projector::projectFunctionOntoBasis() does not yet support tensorial degree > 0.");
}
shards::CellTopology shardsTopo = cellTopo->getShardsTopology();
BasisCache basisCache(physicalCellNodes, shardsTopo, *(dofOrderPtr), maxTrialDegree, false);
// assume only L2 projections
IntrepidExtendedTypes::EOperatorExtended op = IntrepidExtendedTypes::OP_VALUE;
// have information, build inner product matrix
int numDofs = basis->getCardinality();
FieldContainer<double> cubPoints = basisCache.getPhysicalCubaturePoints();
FieldContainer<double> basisValues = *(basisCache.getTransformedValues(basis, op));
FieldContainer<double> testBasisValues = *(basisCache.getTransformedWeightedValues(basis, op));
int numCells = physicalCellNodes.dimension(0);
int numPts = cubPoints.dimension(1);
FieldContainer<double> functionValues;
fxn->getValues(functionValues, cubPoints);
FieldContainer<double> gramMatrix(numCells,numDofs,numDofs);
FieldContainer<double> ipVector(numCells,numDofs);
FunctionSpaceTools::integrate<double>(gramMatrix,basisValues,testBasisValues,COMP_BLAS);
FunctionSpaceTools::integrate<double>(ipVector,functionValues,testBasisValues,COMP_BLAS);
basisCoefficients.resize(numCells,numDofs);
for (int cellIndex=0; cellIndex<numCells; cellIndex++){
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));
/*
cout << "matrix A = " << endl;
for (int i=0;i<gramMatrix.dimension(2);i++){
for (int j=0;j<gramMatrix.dimension(1);j++){
cout << A(i,j) << " ";
}
cout << endl;
}
cout << endl;
cout << "vector B = " << endl;
for (int i=0;i<functionValues.dimension(1);i++){
cout << b(i) << endl;
}
*/
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;
}
}
for (int i=0;i<numDofs;i++){
basisCoefficients(cellIndex,i) = x(i);
}
}
}
void RieszRep::computeRieszRep(int cubatureEnrichment){
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
//cout << "rank: " << rank << " of " << numProcs << endl;
#else
Epetra_SerialComm Comm;
#endif
set<GlobalIndexType> cellIDs = _mesh->cellIDsInPartition();
for (set<GlobalIndexType>::iterator cellIDIt=cellIDs.begin(); cellIDIt !=cellIDs.end(); cellIDIt++){
GlobalIndexType cellID = *cellIDIt;
ElementTypePtr elemTypePtr = _mesh->getElementType(cellID);
DofOrderingPtr testOrderingPtr = elemTypePtr->testOrderPtr;
int numTestDofs = testOrderingPtr->totalDofs();
BasisCachePtr basisCache = BasisCache::basisCacheForCell(_mesh,cellID,true,cubatureEnrichment);
FieldContainer<double> rhsValues(1,numTestDofs);
_rhs->integrate(rhsValues, testOrderingPtr, basisCache);
if (_printAll){
cout << "RieszRep: LinearTerm values for cell " << cellID << ":\n " << rhsValues << endl;
}
FieldContainer<double> ipMatrix(1,numTestDofs,numTestDofs);
_ip->computeInnerProductMatrix(ipMatrix,testOrderingPtr, basisCache);
bool printOutRiesz = false;
if (printOutRiesz){
cout << " ============================ In RIESZ ==========================" << endl;
cout << "matrix: \n" << ipMatrix;
}
FieldContainer<double> rieszRepDofs(numTestDofs,1);
ipMatrix.resize(numTestDofs,numTestDofs);
rhsValues.resize(numTestDofs,1);
int success = SerialDenseWrapper::solveSystemUsingQR(rieszRepDofs, ipMatrix, rhsValues);
if (success != 0) {
cout << "RieszRep::computeRieszRep: Solve FAILED with error: " << success << endl;
}
// rieszRepDofs.Multiply(true,rhsVectorCopy, normSq); // equivalent to e^T * R_V * e
double normSquared = SerialDenseWrapper::dot(rieszRepDofs, rhsValues);
_rieszRepNormSquared[cellID] = normSquared;
// cout << "normSquared for cell " << cellID << ": " << _rieszRepNormSquared[cellID] << endl;
if (printOutRiesz){
cout << "rhs: \n" << rhsValues;
cout << "dofs: \n" << rieszRepDofs;
cout << " ================================================================" << endl;
}
FieldContainer<double> dofs(numTestDofs);
for (int i = 0;i<numTestDofs;i++){
dofs(i) = rieszRepDofs(i,0);
}
_rieszRepDofs[cellID] = dofs;
}
distributeDofs();
_repsNotComputed = false;
}
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 Boundary::bcsToImpose( map< GlobalIndexType, Scalar > &globalDofIndicesAndValues, TBC<Scalar> &bc,
GlobalIndexType cellID, DofInterpreter* dofInterpreter)
{
// this is where we actually compute the BCs; the other bcsToImpose variants call this one.
CellPtr cell = _mesh->getTopology()->getCell(cellID);
// define a couple of important inner products:
TIPPtr<Scalar> ipL2 = Teuchos::rcp( new TIP<Scalar> );
TIPPtr<Scalar> ipH1 = Teuchos::rcp( new TIP<Scalar> );
VarFactoryPtr varFactory = VarFactory::varFactory();
VarPtr trace = varFactory->traceVar("trace");
VarPtr flux = varFactory->traceVar("flux");
ipL2->addTerm(flux);
ipH1->addTerm(trace);
ipH1->addTerm(trace->grad());
ElementTypePtr elemType = _mesh->getElementType(cellID);
DofOrderingPtr trialOrderingPtr = elemType->trialOrderPtr;
vector< int > trialIDs = _mesh->bilinearForm()->trialIDs();
vector<unsigned> boundarySides = cell->boundarySides();
if (boundarySides.size() > 0)
{
BasisCachePtr basisCache = BasisCache::basisCacheForCell(_mesh, cellID);
for (vector< int >::iterator trialIt = trialIDs.begin(); trialIt != trialIDs.end(); trialIt++)
{
int trialID = *(trialIt);
if ( bc.bcsImposed(trialID) )
{
// // DEBUGGING: keep track of which sides we impose BCs on:
// set<unsigned> bcImposedSides;
//
// Determine global dof indices and values, in one pass per side
for (int i=0; i<boundarySides.size(); i++)
{
unsigned sideOrdinal = boundarySides[i];
// TODO: here, we need to treat the volume basis case.
/*
To do this:
1. (Determine which dofs in the basis have support on the side.)
2. (Probably should resize dirichletValues to match number of dofs with support on the side.)
3. (Within coefficientsForBC, and the projection method it calls, when it's a side cache, check whether the basis being projected has a higher dimension. If so, do the same determination regarding the support of basis on the side as #1.)
4. DofInterpreter::interpretLocalBasisCoefficients() needs to handle the case that trialID has volume support, and in this case interpret the provided data appropriately.
*/
BasisPtr basis;
int numDofsSide;
if (trialOrderingPtr->getSidesForVarID(trialID).size() == 1)
{
// volume basis
basis = trialOrderingPtr->getBasis(trialID);
// get the dof ordinals for the side (interpreted as a "continuous" basis)
numDofsSide = basis->dofOrdinalsForSide(sideOrdinal).size();
}
else if (! trialOrderingPtr->hasBasisEntry(trialID, sideOrdinal))
{
continue;
}
else
{
basis = trialOrderingPtr->getBasis(trialID,sideOrdinal);
numDofsSide = basis->getCardinality();
}
GlobalIndexType numCells = 1;
if (numCells > 0)
{
FieldContainer<double> dirichletValues(numCells,numDofsSide);
// project bc function onto side basis:
BCPtr bcPtr = Teuchos::rcp(&bc, false);
Teuchos::RCP<BCFunction<double>> bcFunction = BCFunction<double>::bcFunction(bcPtr, trialID);
bcPtr->coefficientsForBC(dirichletValues, bcFunction, basis, basisCache->getSideBasisCache(sideOrdinal));
dirichletValues.resize(numDofsSide);
if (bcFunction->imposeOnCell(0))
{
FieldContainer<double> globalData;
FieldContainer<GlobalIndexType> globalDofIndices;
dofInterpreter->interpretLocalBasisCoefficients(cellID, trialID, sideOrdinal, dirichletValues, globalData, globalDofIndices);
for (int globalDofOrdinal=0; globalDofOrdinal<globalDofIndices.size(); globalDofOrdinal++)
{
GlobalIndexType globalDofIndex = globalDofIndices(globalDofOrdinal);
Scalar value = globalData(globalDofOrdinal);
// sanity check: if this has been previously set, do the two values roughly agree?
if (globalDofIndicesAndValues.find(globalDofIndex) != globalDofIndicesAndValues.end())
{
double tol = 1e-10;
Scalar prevValue = globalDofIndicesAndValues[globalDofIndex];
double absDiff = abs(prevValue - value);
if (absDiff > tol)
{
double relativeDiff = absDiff / max(abs(prevValue),abs(value));
int rank = _mesh->Comm()->MyPID();
if (relativeDiff > tol)
{
cout << "WARNING: in Boundary::bcsToImpose(), inconsistent values for BC: " << prevValue << " and ";
cout << value << " prescribed for global dof index " << globalDofIndex;
cout << " on rank " << rank << endl;
}
}
}
globalDofIndicesAndValues[globalDofIndex] = value;
}
}
}
}
}
}
}
}
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;
}
void Boundary::singletonBCsToImpose(std::map<GlobalIndexType,Scalar> &dofIndexToValue, TBC<Scalar> &bc,
DofInterpreter* dofInterpreter)
{
// first, let's check for any singletons (one-point BCs)
map<IndexType, set < pair<int, unsigned> > > singletonsForCell;
const set<GlobalIndexType>* rankLocalCells = &_mesh->cellIDsInPartition();
vector< int > trialIDs = _mesh->bilinearForm()->trialIDs();
for (int trialID : trialIDs)
{
if (bc.singlePointBC(trialID))
{
auto knownActiveCells = &_mesh->getTopology()->getLocallyKnownActiveCellIndices();
vector<double> spatialVertex = bc.pointForSpatialPointBC(trialID);
vector<IndexType> matchingVertices = _mesh->getTopology()->getVertexIndicesMatching(spatialVertex);
unsigned vertexDim = 0;
for (IndexType vertexIndex : matchingVertices)
{
set< pair<IndexType, unsigned> > cellsForVertex = _mesh->getTopology()->getCellsContainingEntity(vertexDim, vertexIndex);
for (pair<IndexType, unsigned> cellForVertex : cellsForVertex)
{
// active cell
IndexType matchingCellID = cellForVertex.first;
if (rankLocalCells->find(matchingCellID) != rankLocalCells->end()) // we own this cell, so we're responsible for imposing the singleton BC
{
CellPtr cell = _mesh->getTopology()->getCell(matchingCellID);
unsigned vertexOrdinal = cell->findSubcellOrdinal(vertexDim, vertexIndex);
TEUCHOS_TEST_FOR_EXCEPTION(vertexOrdinal == -1, std::invalid_argument, "Internal error: vertexOrdinal not found for cell to which it supposedly belongs");
singletonsForCell[matchingCellID].insert(make_pair(trialID, vertexOrdinal));
}
}
}
}
}
for (auto cellEntry : singletonsForCell)
{
GlobalIndexType cellID = cellEntry.first;
auto singletons = cellEntry.second;
ElementTypePtr elemType = _mesh->getElementType(cellID);
map<int, vector<unsigned> > vertexOrdinalsForTrialID;
for (pair<int, unsigned> trialVertexPair : singletons)
{
vertexOrdinalsForTrialID[trialVertexPair.first].push_back(trialVertexPair.second);
}
for (auto trialVertexOrdinals : vertexOrdinalsForTrialID)
{
int trialID = trialVertexOrdinals.first;
vector<unsigned> vertexOrdinalsInCell = trialVertexOrdinals.second;
CellTopoPtr cellTopo = elemType->cellTopoPtr;
CellTopoPtr spatialCellTopo;
bool spaceTime;
int vertexOrdinalInSpatialCell;
if (vertexOrdinalsInCell.size() == 2)
{
// we'd better be doing space-time in this case, and the vertices should be the same spatially
spaceTime = (cellTopo->getTensorialDegree() > 0);
TEUCHOS_TEST_FOR_EXCEPTION(!spaceTime, std::invalid_argument, "multiple vertices for spatial point only supported for space-time");
spatialCellTopo = cellTopo->getTensorialComponent();
vertexOrdinalInSpatialCell = -1;
for (unsigned spatialVertexOrdinal = 0; spatialVertexOrdinal < spatialCellTopo->getNodeCount(); spatialVertexOrdinal++)
{
vector<unsigned> tensorComponentNodes = {spatialVertexOrdinal,0};
unsigned spaceTimeVertexOrdinal_t0 = cellTopo->getNodeFromTensorialComponentNodes(tensorComponentNodes);
if ((spaceTimeVertexOrdinal_t0 == vertexOrdinalsInCell[0]) || (spaceTimeVertexOrdinal_t0 == vertexOrdinalsInCell[1]))
{
// then this should be our match. Confirm this:
tensorComponentNodes = {spatialVertexOrdinal,1};
unsigned spaceTimeVertexOrdinal_t1 = cellTopo->getNodeFromTensorialComponentNodes(tensorComponentNodes);
bool t1VertexMatches = (spaceTimeVertexOrdinal_t1 == vertexOrdinalsInCell[0]) || (spaceTimeVertexOrdinal_t1 == vertexOrdinalsInCell[1]);
TEUCHOS_TEST_FOR_EXCEPTION(!t1VertexMatches, std::invalid_argument, "Internal error: space-time vertices do not belong to the same spatial vertex");
vertexOrdinalInSpatialCell = spatialVertexOrdinal;
break;
}
}
TEUCHOS_TEST_FOR_EXCEPTION(vertexOrdinalInSpatialCell == -1, std::invalid_argument, "Internal error: spatial vertex ordinal not found");
}
else if (vertexOrdinalsInCell.size() == 1)
{
spaceTime = false;
spatialCellTopo = cellTopo;
vertexOrdinalInSpatialCell = vertexOrdinalsInCell[0];
}
else
{
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "vertexOrdinalsInCell must have 1 or 2 vertices");
}
set<GlobalIndexType> globalIndicesForVariable;
DofOrderingPtr trialOrderingPtr = elemType->trialOrderPtr;
int numSpatialSides = spatialCellTopo->getSideCount();
vector<unsigned> spatialSidesForVertex;
vector<unsigned> sideVertexOrdinals; // same index in this container as spatialSidesForVertex: gets the node ordinal of the vertex in that side
int sideDim = spatialCellTopo->getDimension() - 1;
if (!_mesh->bilinearForm()->isFluxOrTrace(trialID))
{
spatialSidesForVertex.push_back(VOLUME_INTERIOR_SIDE_ORDINAL);
sideVertexOrdinals.push_back(vertexOrdinalInSpatialCell);
}
else
{
for (int spatialSideOrdinal=0; spatialSideOrdinal < numSpatialSides; spatialSideOrdinal++)
{
CellTopoPtr sideTopo = spatialCellTopo->getSide(spatialSideOrdinal);
for (unsigned sideVertexOrdinal = 0; sideVertexOrdinal < sideTopo->getNodeCount(); sideVertexOrdinal++)
{
unsigned spatialVertexOrdinal = spatialCellTopo->getNodeMap(sideDim, spatialSideOrdinal, sideVertexOrdinal);
if (spatialVertexOrdinal == vertexOrdinalInSpatialCell)
{
spatialSidesForVertex.push_back(spatialSideOrdinal);
sideVertexOrdinals.push_back(sideVertexOrdinal);
break; // this is the only match we should find on this side
}
}
}
if (spatialSidesForVertex.size() == 0)
{
cout << "ERROR: no spatial side for vertex found during singleton BC imposition.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "no spatial side for vertex found during singleton BC imposition");
}
}
for (int i=0; i<spatialSidesForVertex.size(); i++)
{
unsigned spatialSideOrdinal = spatialSidesForVertex[i];
unsigned vertexOrdinalInSide = sideVertexOrdinals[i];
unsigned sideForImposition;
BasisPtr spatialBasis, temporalBasis, spaceTimeBasis, basisForImposition;
if (!spaceTime)
{
spatialBasis = trialOrderingPtr->getBasis(trialID,spatialSideOrdinal);
sideForImposition = spatialSideOrdinal;
}
else
{
unsigned spaceTimeSideOrdinal;
if (!_mesh->bilinearForm()->isFluxOrTrace(trialID))
{
spaceTimeSideOrdinal = VOLUME_INTERIOR_SIDE_ORDINAL;
}
else
{
spaceTimeSideOrdinal = cellTopo->getSpatialSideOrdinal(spatialSideOrdinal);
}
spaceTimeBasis = trialOrderingPtr->getBasis(trialID,spaceTimeSideOrdinal);
sideForImposition = spaceTimeSideOrdinal;
TensorBasis<>* tensorBasis = dynamic_cast<TensorBasis<>*>(spaceTimeBasis.get());
TEUCHOS_TEST_FOR_EXCEPTION(!tensorBasis, std::invalid_argument, "space-time basis must be a subclass of TensorBasis");
if (tensorBasis)
{
spatialBasis = tensorBasis->getSpatialBasis();
temporalBasis = tensorBasis->getTemporalBasis();
}
}
bool constantSpatialBasis = false;
// upgrade bases to continuous ones of the same cardinality, if they are discontinuous.
if (spatialBasis->getDegree() == 0)
{
constantSpatialBasis = true;
}
else if ((spatialBasis->functionSpace() == Camellia::FUNCTION_SPACE_HVOL) ||
(spatialBasis->functionSpace() == Camellia::FUNCTION_SPACE_HVOL_DISC))
{
spatialBasis = BasisFactory::basisFactory()->getBasis(spatialBasis->getDegree(), spatialBasis->domainTopology(), Camellia::FUNCTION_SPACE_HGRAD);
}
else if (Camellia::functionSpaceIsDiscontinuous(spatialBasis->functionSpace()))
{
Camellia::EFunctionSpace fsContinuous = Camellia::continuousSpaceForDiscontinuous((spatialBasis->functionSpace()));
spatialBasis = BasisFactory::basisFactory()->getBasis(spatialBasis->getDegree(), spatialBasis->domainTopology(), fsContinuous,
Camellia::FUNCTION_SPACE_HGRAD);
}
if (temporalBasis.get())
{
if ((temporalBasis->functionSpace() == Camellia::FUNCTION_SPACE_HVOL) ||
(temporalBasis->functionSpace() == Camellia::FUNCTION_SPACE_HVOL_DISC))
{
temporalBasis = BasisFactory::basisFactory()->getBasis(temporalBasis->getDegree(), temporalBasis->domainTopology(), Camellia::FUNCTION_SPACE_HGRAD);
}
else if (Camellia::functionSpaceIsDiscontinuous(temporalBasis->functionSpace()))
{
Camellia::EFunctionSpace fsContinuous = Camellia::continuousSpaceForDiscontinuous((temporalBasis->functionSpace()));
temporalBasis = BasisFactory::basisFactory()->getBasis(temporalBasis->getDegree(), temporalBasis->domainTopology(), fsContinuous,
Camellia::FUNCTION_SPACE_HGRAD);
}
}
if (spaceTime)
{
if (constantSpatialBasis)
{ // then use the original basis for imposition
basisForImposition = spaceTimeBasis;
}
else
{
vector<int> H1Orders = {spatialBasis->getDegree(),temporalBasis->getDegree()};
spaceTimeBasis = BasisFactory::basisFactory()->getBasis(H1Orders, spaceTimeBasis->domainTopology(), spatialBasis->functionSpace(), temporalBasis->functionSpace());
basisForImposition = spaceTimeBasis;
}
}
else
{
basisForImposition = spatialBasis;
}
vector<int> spatialDofOrdinalsForVertex = constantSpatialBasis ? vector<int>{0} : spatialBasis->dofOrdinalsForVertex(vertexOrdinalInSide);
if (spatialDofOrdinalsForVertex.size() != 1)
{
cout << "ERROR: spatialDofOrdinalsForVertex.size() != 1 during singleton BC imposition.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "spatialDofOrdinalsForVertex.size() != 1 during singleton BC imposition");
}
int spatialDofOrdinalForVertex = spatialDofOrdinalsForVertex[0];
vector<int> basisDofOrdinals;
if (!spaceTime)
{
basisDofOrdinals.push_back(spatialDofOrdinalForVertex);
}
else
{
int temporalBasisCardinality = temporalBasis->getCardinality();
TensorBasis<>* tensorBasis = dynamic_cast<TensorBasis<>*>(spaceTimeBasis.get());
for (int temporalBasisOrdinal=0; temporalBasisOrdinal<temporalBasisCardinality; temporalBasisOrdinal++)
{
basisDofOrdinals.push_back(tensorBasis->getDofOrdinalFromComponentDofOrdinals({spatialDofOrdinalForVertex, temporalBasisOrdinal}));
}
}
for (int dofOrdinal : basisDofOrdinals)
{
FieldContainer<double> basisCoefficients(basisForImposition->getCardinality());
basisCoefficients[dofOrdinal] = 1.0;
FieldContainer<double> globalCoefficients;
FieldContainer<GlobalIndexType> globalDofIndices;
dofInterpreter->interpretLocalBasisCoefficients(cellID, trialID, sideForImposition, basisCoefficients,
globalCoefficients, globalDofIndices);
double tol = 1e-14;
int nonzeroEntryOrdinal = -1;
for (int fieldOrdinal=0; fieldOrdinal < globalCoefficients.size(); fieldOrdinal++)
{
if (abs(globalCoefficients[fieldOrdinal]) > tol)
{
if (nonzeroEntryOrdinal != -1)
{
// previous nonzero entry found; this is a problem--it means we have multiple global coefficients that depend on this vertex
// (could happen if user specified a hanging node)
cout << "Error: vertex for single-point imposition has multiple global degrees of freedom.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "Error: vertex for single-point imposition has multiple global degrees of freedom.");
}
// nonzero entry: store the fact, and impose the constraint
nonzeroEntryOrdinal = fieldOrdinal;
bool isRankLocal = dofInterpreter->isLocallyOwnedGlobalDofIndex(globalDofIndices[fieldOrdinal]);
if (isRankLocal)
{
dofIndexToValue[globalDofIndices[fieldOrdinal]] = bc.valueForSinglePointBC(trialID) * globalCoefficients[fieldOrdinal];
}
else
{
cout << "ERROR: global dof index for single-point BC is not locally owned.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "ERROR: global dof index for single-point BC is not locally owned");
}
}
}
}
}
}
}
}
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;
}
bool FunctionTests::testBasisSumFunction()
{
bool success = true;
// on a single-element mesh, the BasisSumFunction should be identical to
// the Solution with those coefficients
// define a new mesh: more interesting if we're not on the ref cell
int spaceDim = 2;
FieldContainer<double> quadPoints(4,2);
quadPoints(0,0) = 0.0; // x1
quadPoints(0,1) = 0.0; // y1
quadPoints(1,0) = 2.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 = 1, pToAdd = 0;
int horizontalCells = 1, verticalCells = 1;
// create a pointer to a new mesh:
MeshPtr spectralConfusionMesh = MeshFactory::buildQuadMesh(quadPoints, horizontalCells, verticalCells,
_confusionBF, H1Order, H1Order+pToAdd);
BCPtr bc = BC::bc();
SolutionPtr soln = Teuchos::rcp( new Solution(spectralConfusionMesh, bc) );
soln->initializeLHSVector();
int cellID = 0;
double tol = 1e-16; // overly restrictive, just for now.
DofOrderingPtr trialSpace = spectralConfusionMesh->getElementType(cellID)->trialOrderPtr;
set<int> trialIDs = trialSpace->getVarIDs();
BasisCachePtr volumeCache = BasisCache::basisCacheForCell(spectralConfusionMesh, cellID);
for (set<int>::iterator trialIt=trialIDs.begin(); trialIt != trialIDs.end(); trialIt++)
{
int trialID = *trialIt;
const vector<int>* sidesForVar = &trialSpace->getSidesForVarID(trialID);
bool boundaryValued = sidesForVar->size() != 1;
// note that for volume trialIDs, sideIndex = 0, and numSides = 1…
for (vector<int>::const_iterator sideIt = sidesForVar->begin(); sideIt != sidesForVar->end(); sideIt++)
{
int sideIndex = *sideIt;
BasisCachePtr sideCache = volumeCache->getSideBasisCache(sideIndex);
BasisPtr basis = trialSpace->getBasis(trialID, sideIndex);
int basisCardinality = basis->getCardinality();
for (int basisOrdinal = 0; basisOrdinal<basisCardinality; basisOrdinal++)
{
FieldContainer<double> basisCoefficients(basisCardinality);
basisCoefficients(basisOrdinal) = 1.0;
soln->setSolnCoeffsForCellID(basisCoefficients, cellID, trialID, sideIndex);
VarPtr v = Var::varForTrialID(trialID, spectralConfusionMesh->bilinearForm());
FunctionPtr solnFxn = Function::solution(v, soln, false);
FunctionPtr basisSumFxn = Teuchos::rcp( new BasisSumFunction(basis, basisCoefficients, Teuchos::rcp((BasisCache*)NULL), OP_VALUE, boundaryValued) );
if (!boundaryValued)
{
double l2diff = (solnFxn - basisSumFxn)->l2norm(spectralConfusionMesh);
// cout << "l2diff = " << l2diff << endl;
if (l2diff > tol)
{
success = false;
cout << "testBasisSumFunction: l2diff of " << l2diff << " exceeds tol of " << tol << endl;
cout << "l2norm of basisSumFxn: " << basisSumFxn->l2norm(spectralConfusionMesh) << endl;
cout << "l2norm of solnFxn: " << solnFxn->l2norm(spectralConfusionMesh) << endl;
}
l2diff = (solnFxn->dx() - basisSumFxn->dx())->l2norm(spectralConfusionMesh);
// cout << "l2diff = " << l2diff << endl;
if (l2diff > tol)
{
success = false;
cout << "testBasisSumFunction: l2diff of dx() " << l2diff << " exceeds tol of " << tol << endl;
cout << "l2norm of basisSumFxn->dx(): " << basisSumFxn->dx()->l2norm(spectralConfusionMesh) << endl;
cout << "l2norm of solnFxn->dx(): " << solnFxn->dx()->l2norm(spectralConfusionMesh) << endl;
}
// test that the restriction to a side works
int numSides = volumeCache->cellTopology()->getSideCount();
for (int i=0; i<numSides; i++)
{
BasisCachePtr mySideCache = volumeCache->getSideBasisCache(i);
if (! solnFxn->equals(basisSumFxn, mySideCache, tol))
{
success = false;
cout << "testBasisSumFunction: on side 0, l2diff of " << l2diff << " exceeds tol of " << tol << endl;
reportFunctionValueDifferences(solnFxn, basisSumFxn, mySideCache, tol);
}
if (! solnFxn->grad(spaceDim)->equals(basisSumFxn->grad(spaceDim), mySideCache, tol))
{
success = false;
cout << "testBasisSumFunction: on side 0, l2diff of dx() " << l2diff << " exceeds tol of " << tol << endl;
reportFunctionValueDifferences(solnFxn->grad(spaceDim), basisSumFxn->grad(spaceDim), mySideCache, tol);
}
}
}
else
{
FieldContainer<double> cellIntegral(1);
// compute l2 diff of integral along the one side where we can legitimately assert equality:
FunctionPtr diffFxn = solnFxn - basisSumFxn;
(diffFxn*diffFxn)->integrate(cellIntegral, sideCache);
double l2diff = sqrt(cellIntegral(0));
if (l2diff > tol)
{
success = false;
cout << "testBasisSumFunction: on side " << sideIndex << ", l2diff of " << l2diff << " exceeds tol of " << tol << endl;
int numCubPoints = sideCache->getPhysicalCubaturePoints().dimension(1);
FieldContainer<double> solnFxnValues(1,numCubPoints);
FieldContainer<double> basisFxnValues(1,numCubPoints);
solnFxn->values(solnFxnValues, sideCache);
basisSumFxn->values(basisFxnValues, sideCache);
cout << "solnFxnValues:\n" << solnFxnValues;
cout << "basisFxnValues:\n" << basisFxnValues;
}
else
{
// cout << "testBasisSumFunction: on side " << sideIndex << ", l2diff of " << l2diff << " is within tol of " << tol << endl;
}
}
}
}
}
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);
}
virtual void localStiffnessMatrixAndRHS(FieldContainer<double> &localStiffness, FieldContainer<double> &rhsVector,
IPPtr ip, BasisCachePtr ipBasisCache,
RHSPtr rhs, BasisCachePtr basisCache) {
double testMatrixAssemblyTime = 0, testMatrixInversionTime = 0, localStiffnessDeterminationFromTestsTime = 0;
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
//cout << "rank: " << rank << " of " << numProcs << endl;
#else
Epetra_SerialComm Comm;
#endif
Epetra_Time timer(Comm);
// localStiffness should have dim. (numCells, numTrialFields, numTrialFields)
MeshPtr mesh = basisCache->mesh();
if (mesh.get() == NULL) {
cout << "localStiffnessMatrix requires BasisCache to have mesh set.\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "localStiffnessMatrix requires BasisCache to have mesh set.");
}
const vector<GlobalIndexType>* cellIDs = &basisCache->cellIDs();
int numCells = cellIDs->size();
if (numCells != localStiffness.dimension(0)) {
cout << "localStiffnessMatrix requires basisCache->cellIDs() to have the same # of cells as the first dimension of localStiffness\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "localStiffnessMatrix requires basisCache->cellIDs() to have the same # of cells as the first dimension of localStiffness");
}
ElementTypePtr elemType = mesh->getElementType((*cellIDs)[0]); // we assume all cells provided are of the same type
DofOrderingPtr trialOrder = elemType->trialOrderPtr;
DofOrderingPtr fieldOrder = mesh->getDofOrderingFactory().getFieldOrdering(trialOrder);
DofOrderingPtr traceOrder = mesh->getDofOrderingFactory().getTraceOrdering(trialOrder);
map<int, int> stiffnessIndexForTraceIndex;
map<int, int> stiffnessIndexForFieldIndex;
set<int> varIDs = trialOrder->getVarIDs();
for (set<int>::iterator varIt = varIDs.begin(); varIt != varIDs.end(); varIt++) {
int varID = *varIt;
const vector<int>* sidesForVar = &trialOrder->getSidesForVarID(varID);
bool isTrace = (sidesForVar->size() > 1);
for (vector<int>::const_iterator sideIt = sidesForVar->begin(); sideIt != sidesForVar->end(); sideIt++) {
int sideOrdinal = *sideIt;
vector<int> dofIndices = trialOrder->getDofIndices(varID,sideOrdinal);
if (isTrace) {
vector<int> traceDofIndices = traceOrder->getDofIndices(varID,sideOrdinal);
for (int i=0; i<traceDofIndices.size(); i++) {
stiffnessIndexForTraceIndex[traceDofIndices[i]] = dofIndices[i];
}
} else {
vector<int> fieldDofIndices = fieldOrder->getDofIndices(varID);
for (int i=0; i<fieldDofIndices.size(); i++) {
stiffnessIndexForFieldIndex[fieldDofIndices[i]] = dofIndices[i];
}
}
}
}
int numTrialDofs = trialOrder->totalDofs();
if ((numTrialDofs != localStiffness.dimension(1)) || (numTrialDofs != localStiffness.dimension(2))) {
cout << "localStiffness should have dimensions (C,numTrialFields,numTrialFields).\n";
TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument, "localStiffness should have dimensions (C,numTrialFields,numTrialFields).");
}
map<int,int> traceTestMap, fieldTestMap;
int numEquations = _virtualTerms.getFieldTestVars().size();
for (int eqn=0; eqn<numEquations; eqn++) {
VarPtr testVar = _virtualTerms.getFieldTestVars()[eqn];
VarPtr traceVar = _virtualTerms.getAssociatedTrace(testVar);
VarPtr fieldVar = _virtualTerms.getAssociatedField(testVar);
traceTestMap[traceVar->ID()] = testVar->ID();
fieldTestMap[fieldVar->ID()] = testVar->ID();
}
int maxDegreeField = fieldOrder->maxBasisDegree();
int testDegreeInterior = maxDegreeField + _virtualTerms.getTestEnrichment();
int testDegreeTrace = testDegreeInterior + 2;
cout << "ERROR in Virtual: getRelabeledDofOrdering() is commented out in DofOrderingFactory. Need to rewrite for the new caching scheme.\n";
DofOrderingPtr testOrderInterior; // = mesh->getDofOrderingFactory().getRelabeledDofOrdering(fieldOrder, fieldTestMap);
testOrderInterior = mesh->getDofOrderingFactory().setBasisDegree(testOrderInterior, testDegreeInterior, false);
DofOrderingPtr testOrderTrace = mesh->getDofOrderingFactory().setBasisDegree(testOrderInterior, testDegreeTrace, true); // this has a bunch of extra dofs (interior guys)
map<int, int> remappedTraceIndices; // go from the index that includes the interior dofs to one that doesn't
set<int> testIDs = testOrderTrace->getVarIDs();
int testTraceIndex = 0;
for (set<int>::iterator testIDIt = testIDs.begin(); testIDIt != testIDs.end(); testIDIt++) {
int testID = *testIDIt;
BasisPtr basis = testOrderTrace->getBasis(testID);
vector<int> interiorDofs = basis->dofOrdinalsForInterior();
for (int basisOrdinal=0; basisOrdinal<basis->getCardinality(); basisOrdinal++) {
if (std::find(interiorDofs.begin(),interiorDofs.end(),basisOrdinal) == interiorDofs.end()) {
int dofIndex = testOrderTrace->getDofIndex(testID, basisOrdinal);
remappedTraceIndices[dofIndex] = testTraceIndex;
testTraceIndex++;
}
}
}
// DofOrderingPtr testOrderTrace = mesh->getDofOrderingFactory().getRelabeledDofOrdering(traceOrder, traceTestMap);
// testOrderTrace = mesh->getDofOrderingFactory().setBasisDegree(testOrderTrace, testDegreeTrace);
int numTestInteriorDofs = testOrderInterior->totalDofs();
int numTestTraceDofsIncludingInterior = testOrderTrace->totalDofs();
int numTestTraceDofs = testTraceIndex;
int numTestDofs = numTestTraceDofs + numTestInteriorDofs;
timer.ResetStartTime();
bool printTimings = true;
if (printTimings) {
cout << "numCells: " << numCells << endl;
cout << "numTestDofs: " << numTestDofs << endl;
}
FieldContainer<double> rhsVectorTest(numCells,testOrderInterior->totalDofs()); // rhsVector is zero for the "trace" test dofs
{
// project the load f onto the space of interior test dofs.
LinearTermPtr f = rhs->linearTerm();
set<int> testIDs = f->varIDs();
for (int eqn=0; eqn<numEquations; eqn++) {
VarPtr v = _virtualTerms.getFieldTestVars()[eqn];
if (testIDs.find(v->ID()) != testIDs.end()) {
BasisPtr testInteriorBasis = testOrderInterior->getBasis(v->ID());
FieldContainer<double> fValues(numCells,testInteriorBasis->getCardinality());
// DofOrderingPtr oneVarOrderingTest = Teuchos::rcp(new DofOrdering(testInteriorBasis->domainTopology()));
DofOrderingPtr oneVarOrderingTest = Teuchos::rcp(new DofOrdering);
oneVarOrderingTest->addEntry(v->ID(), testInteriorBasis, testInteriorBasis->rangeRank());
LinearTermPtr f_v = Teuchos::rcp( new LinearTerm );
typedef pair< FunctionPtr, VarPtr > LinearSummand;
vector<LinearSummand> summands = f->summands();
for (int i=0; i<summands.size(); i++) {
FunctionPtr f = summands[i].first;
if (v->ID() == summands[i].second->ID()) {
f_v->addTerm(f * v);
f_v->integrate(fValues, oneVarOrderingTest, basisCache);
}
}
LinearTermPtr v_lt = 1.0 * v;
FieldContainer<double> l2(numCells,testInteriorBasis->getCardinality(),testInteriorBasis->getCardinality());
v_lt->integrate(l2,oneVarOrderingTest,v_lt,oneVarOrderingTest,basisCache,basisCache->isSideCache());
Teuchos::Array<int> testTestDim(2), testOneDim(2);
testTestDim[0] = testInteriorBasis->getCardinality();
testTestDim[1] = testInteriorBasis->getCardinality();
testOneDim[0] = testInteriorBasis->getCardinality();
testOneDim[1] = 1;
FieldContainer<double> projection(testOneDim);
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
FieldContainer<double> l2cell(testTestDim,&l2(cellOrdinal,0,0));
FieldContainer<double> f_cell(testOneDim,&fValues(cellOrdinal,0));
SerialDenseWrapper::solveSystemUsingQR(projection, l2cell, f_cell);
// rows in projection correspond to Ae_i, columns to the e_j. I.e. projection coefficients for e_i are found in the ith row
for (int basisOrdinal_j=0; basisOrdinal_j<projection.dimension(0); basisOrdinal_j++) {
int testIndex = testOrderInterior->getDofIndex(v->ID(), basisOrdinal_j);
rhsVectorTest(cellOrdinal,testIndex) = projection(basisOrdinal_j,0);
}
}
}
}
}
// project strong operator applied to field terms, and use this to populate the top left portion of stiffness matrix:
{
FieldContainer<double> trialFieldTestInterior(numCells, fieldOrder->totalDofs(), testOrderInterior->totalDofs());
for (int eqn=0; eqn<numEquations; eqn++) {
LinearTermPtr Au = _virtualTerms.getFieldOperators()[eqn];
VarPtr v = _virtualTerms.getFieldTestVars()[eqn];
set<int> fieldIDs = Au->varIDs();
for (set<int>::iterator fieldIt = fieldIDs.begin(); fieldIt != fieldIDs.end(); fieldIt++) {
int fieldID = *fieldIt;
// int testID = fieldTestMap[fieldID];
//
// LinearTermPtr testInteriorVar = 1.0 * this->varFactory().test(testID);
BasisPtr vBasis = testOrderInterior->getBasis(v->ID());
BasisPtr fieldTrialBasis = fieldOrder->getBasis(fieldID);
// DofOrderingPtr oneVarOrderingTest = Teuchos::rcp(new DofOrdering(vBasis->domainTopology()));
DofOrderingPtr oneVarOrderingTest = Teuchos::rcp(new DofOrdering());
oneVarOrderingTest->addEntry(v->ID(), vBasis, vBasis->rangeRank());
FieldContainer<double> Au_values(numCells,vBasis->getCardinality(),fieldTrialBasis->getCardinality());
FieldContainer<double> l2(numCells,vBasis->getCardinality(),vBasis->getCardinality());
DofOrderingPtr oneVarOrderingTrial = Teuchos::rcp(new DofOrdering());
// DofOrderingPtr oneVarOrderingTrial = Teuchos::rcp(new DofOrdering(fieldTrialBasis->domainTopology()));
oneVarOrderingTrial->addEntry(fieldID, fieldTrialBasis, fieldTrialBasis->rangeRank());
LinearTermPtr Au_restricted_to_field = Teuchos::rcp( new LinearTerm );
typedef pair< FunctionPtr, VarPtr > LinearSummand;
vector<LinearSummand> summands = Au->summands();
for (int i=0; i<summands.size(); i++) {
FunctionPtr f = summands[i].first;
VarPtr v = summands[i].second;
if (v->ID() == fieldID) {
Au_restricted_to_field->addTerm(f * v);
}
}
LinearTermPtr v_lt = 1.0 * v;
Au_restricted_to_field->integrate(Au_values,oneVarOrderingTrial,v_lt,oneVarOrderingTest,basisCache,basisCache->isSideCache());
v_lt->integrate(l2,oneVarOrderingTest,v_lt,oneVarOrderingTest,basisCache,basisCache->isSideCache());
double maxValue = 0;
for (int i=0; i<l2.size(); i++) {
maxValue = max(abs(l2[i]),maxValue);
}
cout << "maxValue in l2 is " << maxValue << endl;
Teuchos::Array<int> testTestDim(2), trialTestDim(2);
testTestDim[0] = vBasis->getCardinality();
testTestDim[1] = vBasis->getCardinality();
trialTestDim[0] = vBasis->getCardinality();
trialTestDim[1] = fieldTrialBasis->getCardinality();
FieldContainer<double> projection(trialTestDim);
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
FieldContainer<double> l2cell(testTestDim,&l2(cellOrdinal,0,0));
FieldContainer<double> AuCell(trialTestDim,&Au_values(cellOrdinal,0,0));
// TODO: confirm that I'm doing the right projection here. I could be missing a key point, but it seems to me that we must
// project onto an *orthonormal* basis here, to achieve the required identity structure of the (field,field) part of the
// Gram matrix. OTOH, it looks to me like the computation here achieves exactly that, even though I didn't initially
// have that in mind...
// SerialDenseWrapper::solveSystemUsingQR(projection, l2cell, AuCell);
SerialDenseWrapper::solveSystemMultipleRHS(projection, l2cell, AuCell);
// rows in projection correspond to Ae_i, columns to the e_j. I.e. projection coefficients for e_i are found in the ith row
for (int basisOrdinal_i=0; basisOrdinal_i<projection.dimension(0); basisOrdinal_i++) {
int testIndex = testOrderInterior->getDofIndex(v->ID(), basisOrdinal_i);
for (int basisOrdinal_j=0; basisOrdinal_j<projection.dimension(1); basisOrdinal_j++) {
int trialIndex = fieldOrder->getDofIndex(fieldID, basisOrdinal_j); // in the *trial* space
trialFieldTestInterior(cellOrdinal,trialIndex,testIndex) = projection(basisOrdinal_i,basisOrdinal_j);
}
}
}
}
}
Teuchos::Array<int> trialTestDim(2);
trialTestDim[0] = fieldOrder->totalDofs();
trialTestDim[1] = testOrderInterior->totalDofs();
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
FieldContainer<double> trialFieldTrialField(fieldOrder->totalDofs(), fieldOrder->totalDofs());
FieldContainer<double> trialTestCell(trialTestDim, &trialFieldTestInterior(cellOrdinal,0,0));
SerialDenseWrapper::multiply(trialFieldTrialField, trialTestCell, trialTestCell, 'N', 'T'); // transpose the second one
// now, accumulate into localStiffness
for (int i=0; i<trialFieldTrialField.dimension(0); i++) {
int stiff_i = stiffnessIndexForFieldIndex[i];
for (int j=0; j<trialFieldTrialField.dimension(1); j++) {
int stiff_j = stiffnessIndexForFieldIndex[j];
localStiffness(cellOrdinal,stiff_i,stiff_j) = trialFieldTrialField(i,j);
}
}
}
// multiply RHS integrated against the interior test space by the trialFieldTestInterior
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
Teuchos::Array<int> trialTestDim(2), oneTestDim(2);
trialTestDim[0] = fieldOrder->totalDofs();
trialTestDim[1] = testOrderInterior->totalDofs();
oneTestDim[0] = 1;
oneTestDim[1] = testOrderInterior->totalDofs();
FieldContainer<double> trialTestCell(trialTestDim, &trialFieldTestInterior(cellOrdinal,0,0));
FieldContainer<double> rhsTestCell(oneTestDim, &rhsVectorTest(cellOrdinal,0));
FieldContainer<double> rhsTrialCell(1, fieldOrder->totalDofs());
SerialDenseWrapper::multiply(rhsTrialCell, rhsTestCell, trialTestCell, 'N', 'T');
for (int fieldIndex=0; fieldIndex<fieldOrder->totalDofs(); fieldIndex++) {
int stiffIndex = stiffnessIndexForFieldIndex[fieldIndex];
rhsVector(cellOrdinal,stiffIndex) = rhsTrialCell(0, fieldIndex);
}
}
}
FieldContainer<double> ipMatrixTraceIncludingInterior(numCells,numTestTraceDofsIncludingInterior,numTestTraceDofsIncludingInterior);
int numTestTerms = _virtualTerms.getTestNormOperators().size();
for (int i=0; i<numTestTerms; i++) {
LinearTermPtr testTerm = _virtualTerms.getTestNormOperators()[i];
LinearTermPtr boundaryTerm = _virtualTerms.getTestNormBoundaryOperators()[i];
testTerm->integrate(ipMatrixTraceIncludingInterior,testOrderTrace,boundaryTerm,testOrderTrace,ipBasisCache,ipBasisCache->isSideCache());
}
FieldContainer<double> ipMatrixTrace(numCells,numTestTraceDofs,numTestTraceDofs);
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
for (int i_dofIndex=0; i_dofIndex<numTestTraceDofsIncludingInterior; i_dofIndex++) {
if (remappedTraceIndices.find(i_dofIndex) == remappedTraceIndices.end()) {
continue;
}
int i_remapped = remappedTraceIndices[i_dofIndex];
for (int j_dofIndex=0; j_dofIndex<numTestTraceDofsIncludingInterior; j_dofIndex++) {
if (remappedTraceIndices.find(j_dofIndex) == remappedTraceIndices.end()) {
continue;
}
int j_remapped = remappedTraceIndices[j_dofIndex];
ipMatrixTrace(cellOrdinal,i_remapped,j_remapped) = ipMatrixTraceIncludingInterior(cellOrdinal,i_dofIndex,j_dofIndex);
}
}
}
testMatrixAssemblyTime += timer.ElapsedTime();
// cout << "ipMatrix:\n" << ipMatrix;
timer.ResetStartTime();
cout << "NOTE: we do not yet enforce continuity on the trace test space.\n"; // I *think* this is fine, but I'm not dead certain -- we do of course in the end enforce continuity in GDAMinimumRule
// now, determine the trace part of the bilinear form matrix
FieldContainer<double> bfMatrixTraceTraceIncludingTestInterior(numCells,testOrderTrace->totalDofs(),traceOrder->totalDofs());
FieldContainer<double> bfMatrixFieldTraceIncludingTestInterior(numCells,testOrderTrace->totalDofs(),fieldOrder->totalDofs());
for (int eqn=0; eqn<numEquations; eqn++) {
VarPtr traceVar = _virtualTerms.getTraceVars()[eqn];
LinearTermPtr termTraced = traceVar->termTraced();
LinearTermPtr strongOperator = _virtualTerms.getFieldOperators()[eqn];
VarPtr testVar = _virtualTerms.getFieldTestVars()[eqn];
// want to determine \hat{C}(\hat{e}_i, \phi_j) for \phi_j with support on the boundary
// the \phi_j's with support on the boundary are the ones associated with the trace
LinearTermPtr trialTerm = 1.0 * traceVar;
LinearTermPtr testTerm;
if (traceVar->varType() == TRACE) {
testTerm = Function::normal() * testVar;
} else {
testTerm = 1.0 * testVar;
}
// trialTerm->integrate(bfMatrixTrace,traceOrder,testTerm,testOrderTrace,basisCache,basisCache->isSideCache());
trialTerm->integrate(bfMatrixTraceTraceIncludingTestInterior,traceOrder,testTerm,testOrderTrace,basisCache,basisCache->isSideCache());
termTraced->integrate(bfMatrixFieldTraceIncludingTestInterior,fieldOrder,-testTerm,testOrderTrace,basisCache,basisCache->isSideCache());
}
FieldContainer<double> bfMatrixFieldTrace(numCells,numTestTraceDofs,bfMatrixFieldTraceIncludingTestInterior.dimension(2));
FieldContainer<double> bfMatrixTraceTrace(numCells,numTestTraceDofs,bfMatrixTraceTraceIncludingTestInterior.dimension(2));
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
for (int i_dofIndex=0; i_dofIndex<numTestTraceDofsIncludingInterior; i_dofIndex++) {
if (remappedTraceIndices.find(i_dofIndex) == remappedTraceIndices.end()) {
continue;
}
int i_remapped = remappedTraceIndices[i_dofIndex];
for (int j_dofIndex=0; j_dofIndex<bfMatrixFieldTrace.dimension(2); j_dofIndex++) {
bfMatrixFieldTrace(cellOrdinal,i_remapped,j_dofIndex) = bfMatrixFieldTraceIncludingTestInterior(cellOrdinal,i_dofIndex,j_dofIndex);
}
for (int j_dofIndex=0; j_dofIndex<bfMatrixTraceTrace.dimension(2); j_dofIndex++) {
bfMatrixTraceTrace(cellOrdinal,i_remapped,j_dofIndex) = bfMatrixTraceTraceIncludingTestInterior(cellOrdinal,i_dofIndex,j_dofIndex);
}
}
}
Teuchos::Array<int> ipMatrixDim(2), bfMatrixTraceTraceDim(2), bfMatrixFieldTraceDim(2);
Teuchos::Array<int> traceTraceStiffDim(2), fieldTraceStiffDim(2), fieldFieldStiffDim(2);
ipMatrixDim[0] = ipMatrixTrace.dimension(1);
ipMatrixDim[1] = ipMatrixTrace.dimension(2);
bfMatrixTraceTraceDim[0] = bfMatrixTraceTrace.dimension(1);
bfMatrixTraceTraceDim[1] = bfMatrixTraceTrace.dimension(2);
bfMatrixFieldTraceDim[0] = bfMatrixFieldTrace.dimension(1);
bfMatrixFieldTraceDim[1] = bfMatrixFieldTrace.dimension(2);
traceTraceStiffDim[0] = traceOrder->totalDofs();
traceTraceStiffDim[1] = traceTraceStiffDim[0];
fieldTraceStiffDim[0] = fieldOrder->totalDofs();
fieldTraceStiffDim[1] = traceOrder->totalDofs(); // rectangular
fieldFieldStiffDim[0] = fieldOrder->totalDofs();
fieldFieldStiffDim[1] = fieldOrder->totalDofs();
FieldContainer<double> traceTraceStiffCell(traceTraceStiffDim);
FieldContainer<double> fieldTraceStiffCell(fieldTraceStiffDim);
FieldContainer<double> fieldFieldStiffCell(fieldFieldStiffDim);
for (int cellOrdinal=0; cellOrdinal<numCells; cellOrdinal++) {
FieldContainer<double> ipMatrixCell(ipMatrixDim,&ipMatrixTrace(cellOrdinal,0,0));
FieldContainer<double> optTestCoeffsTraceTrace(numTestTraceDofs,traceOrder->totalDofs());
FieldContainer<double> bfMatrixTraceTraceCell(bfMatrixTraceTraceDim,&bfMatrixTraceTrace(cellOrdinal,0,0));
int result = SerialDenseWrapper::solveSystemUsingQR(optTestCoeffsTraceTrace, ipMatrixCell, bfMatrixTraceTraceCell);
SerialDenseWrapper::multiply(traceTraceStiffCell, bfMatrixTraceTraceCell, optTestCoeffsTraceTrace, 'T', 'N');
// copy into the appropriate spot in localStiffness:
for (int i=0; i<traceTraceStiffDim[0]; i++) {
int i_stiff = stiffnessIndexForTraceIndex[i];
for (int j=0; j<traceTraceStiffDim[1]; j++) {
int j_stiff = stiffnessIndexForTraceIndex[j];
localStiffness(cellOrdinal,i_stiff,j_stiff) = traceTraceStiffCell(i,j);
}
}
// because of the way the matrix blocks line up, we actually don't have to do a second inversion of ipMatrixCell for this part
FieldContainer<double> bfMatrixFieldTraceCell(bfMatrixFieldTraceDim,&bfMatrixFieldTrace(cellOrdinal,0,0));
SerialDenseWrapper::multiply(fieldTraceStiffCell, bfMatrixFieldTraceCell, optTestCoeffsTraceTrace, 'T', 'N');
// copy into the appropriate spots in localStiffness (taking advantage of symmetry):
for (int i=0; i<fieldTraceStiffDim[0]; i++) {
int i_stiff = stiffnessIndexForFieldIndex[i];
for (int j=0; j<fieldTraceStiffDim[1]; j++) {
int j_stiff = stiffnessIndexForTraceIndex[j];
localStiffness(cellOrdinal,i_stiff,j_stiff) = fieldTraceStiffCell(i,j);
localStiffness(cellOrdinal,j_stiff,i_stiff) = fieldTraceStiffCell(i,j);
}
}
// because of the way the matrix blocks line up, we do have some trace contributions in the (field, field) portion of the matrix
// these get added to the field contributions (hence the +=)
FieldContainer<double> optTestCoeffsFieldTrace(numTestTraceDofs,fieldOrder->totalDofs());
result = SerialDenseWrapper::solveSystemUsingQR(optTestCoeffsFieldTrace, ipMatrixCell, bfMatrixFieldTraceCell);
SerialDenseWrapper::multiply(fieldFieldStiffCell, bfMatrixFieldTraceCell, optTestCoeffsFieldTrace, 'T', 'N');
for (int i=0; i<fieldFieldStiffDim[0]; i++) {
int i_stiff = stiffnessIndexForFieldIndex[i];
for (int j=0; j<fieldFieldStiffDim[1]; j++) {
int j_stiff = stiffnessIndexForFieldIndex[j];
localStiffness(cellOrdinal,i_stiff,j_stiff) += fieldFieldStiffCell(i,j);
}
}
}
testMatrixInversionTime += timer.ElapsedTime();
// cout << "optTestCoeffs:\n" << optTestCoeffs;
if (printTimings) {
cout << "testMatrixAssemblyTime: " << testMatrixAssemblyTime << " seconds.\n";
cout << "testMatrixInversionTime: " << testMatrixInversionTime << " seconds.\n";
cout << "localStiffnessDeterminationFromTestsTime: " << localStiffnessDeterminationFromTestsTime << " seconds.\n";
}
}
