void DofOrdering::copyLikeCoefficients( FieldContainer<double> &newValues, Teuchos::RCP<DofOrdering> oldDofOrdering,
const FieldContainer<double> &oldValues ) {
// copy the coefficients for the bases that agree between the two DofOrderings
// requires that "like" bases are actually pointers to the same memory location
TEUCHOS_TEST_FOR_EXCEPTION( newValues.rank() != 1, std::invalid_argument, "newValues.rank() != 1");
TEUCHOS_TEST_FOR_EXCEPTION( newValues.size() != totalDofs(), std::invalid_argument, "newValues.size() != totalDofs()");
TEUCHOS_TEST_FOR_EXCEPTION( oldValues.rank() != 1, std::invalid_argument, "oldValues.rank() != 1");
TEUCHOS_TEST_FOR_EXCEPTION( oldValues.size() != oldDofOrdering->totalDofs(), std::invalid_argument, "oldValues.size() != oldDofOrdering->totalDofs()");
newValues.initialize(0.0);
for (set<int>::iterator varIDIt = varIDs.begin(); varIDIt != varIDs.end(); varIDIt++) {
int varID = *varIDIt;
int numSides = getNumSidesForVarID(varID);
if ( numSides == oldDofOrdering->getNumSidesForVarID(varID) ) {
for (int sideIndex=0; sideIndex < numSides; sideIndex++) {
BasisPtr basis = getBasis(varID,sideIndex);
if (basis.get() == oldDofOrdering->getBasis(varID,sideIndex).get() ) {
// bases alike: copy coefficients
int cardinality = basis->getCardinality();
for (int dofOrdinal=0; dofOrdinal < cardinality; dofOrdinal++) {
int dofIndex = getDofIndex(varID,dofOrdinal,sideIndex);
newValues(dofIndex) = oldValues( oldDofOrdering->getDofIndex(varID,dofOrdinal,sideIndex) );
}
}
}
}
}
}
// 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);
}
void values(FieldContainer<double> &values, BasisCachePtr basisCache)
{
FieldContainer<double> points = basisCache->getPhysicalCubaturePoints();
FieldContainer<double> normals = basisCache->getSideNormals();
int numCells = points.dimension(0);
int numPoints = points.dimension(1);
FieldContainer<double> Tv(numCells,numPoints);
FieldContainer<double> u1v(numCells,numPoints);;
_u1->values(u1v,basisCache);
_T->values(Tv,basisCache);
bool isSubsonic = false;
double min_y = YTOP;
double max_y = 0.0;
values.initialize(0.0);
for (int cellIndex=0; cellIndex<numCells; cellIndex++)
{
for (int ptIndex=0; ptIndex<numPoints; ptIndex++)
{
double x = points(cellIndex,ptIndex,0);
double y = points(cellIndex,ptIndex,1);
double T = Tv(cellIndex,ptIndex);
double un = u1v(cellIndex,ptIndex); // WARNING: ASSUMES NORMAL AT OUTFLOW = (1,0)
double c = sqrt(_gamma * (_gamma-1.0) * _cv * T);
bool outflowMatch = ((abs(x-2.0) < _tol) && (y > 0.0) && (y < YTOP));
bool subsonicMatch = (un < c) && (un > 0.0);
if (subsonicMatch && outflowMatch)
{
values(cellIndex,ptIndex) = 1.0;
isSubsonic = true;
min_y = min(y,min_y);
max_y = max(y,max_y);
// cout << "y = " << y << endl;
}
}
}
if (isSubsonic)
{
// cout << "subsonic in interval y =(" << min_y << "," << max_y << ")" << endl;
}
}
void SpatiallyFilteredFunction<Scalar>::values(FieldContainer<Scalar> &values, BasisCachePtr basisCache)
{
// cout << "Entered SpatiallyFilteredFunction<Scalar>::values()\n";
int numCells = values.dimension(0);
int numPoints = values.dimension(1);
values.initialize(0.0);
Teuchos::Array<int> dim;
values.dimensions(dim);
Teuchos::Array<int> fValuesDim = dim;
int entriesPerPoint = 1;
for (int d=2; d<values.rank(); d++)
{
entriesPerPoint *= dim[d];
dim[d] = 0; // clear so that these indices point to the start of storage for (cellIndex,ptIndex)
}
FieldContainer<bool> pointsMatch(numCells,numPoints);
if (_sf->matchesPoints(pointsMatch,basisCache)) // SOME point matches
{
// cout << "pointsMatch:\n" << pointsMatch;
FieldContainer<Scalar> fValues(fValuesDim);
_f->values(fValues,basisCache);
for (int cellIndex=0; cellIndex<numCells; cellIndex++)
{
dim[0] = cellIndex;
for (int ptIndex=0; ptIndex<numPoints; ptIndex++)
{
dim[1] = ptIndex;
if (pointsMatch(cellIndex,ptIndex))
{
Scalar* value = &values[values.getEnumeration(dim)];
Scalar* fValue = &fValues[fValues.getEnumeration(dim)];
for (int entryIndex=0; entryIndex<entriesPerPoint; entryIndex++)
{
*value++ = *fValue++;
}
}
}
}
}
}
void LagrangeConstraints::getCoefficients(FieldContainer<double> &lhs, FieldContainer<double> &rhs,
int elemConstraintIndex, DofOrderingPtr trialOrdering,
BasisCachePtr basisCache)
{
LinearTermPtr lt = _constraints[elemConstraintIndex].linearTerm();
TFunctionPtr<double> f = _constraints[elemConstraintIndex].f();
lt->integrate(lhs, trialOrdering, basisCache);
bool onBoundary = f->boundaryValueOnly();
if ( !onBoundary )
{
f->integrate(rhs, basisCache);
}
else
{
int numSides = basisCache->cellTopology()->getSideCount();
rhs.initialize(0);
for (int sideIndex=0; sideIndex<numSides; sideIndex++)
{
f->integrate(rhs, basisCache->getSideBasisCache(sideIndex), true); // true: sumInto
}
}
}
virtual void values(FieldContainer<double> &values, BasisCachePtr basisCache)
{
values.initialize(1.0);
vector<GlobalIndexType> contextCellIDs = basisCache->cellIDs();
int cellIndex=0; // keep track of index into values
int entryCount = values.size();
int numCells = values.dimension(0);
int numEntriesPerCell = entryCount / numCells;
for (vector<GlobalIndexType>::iterator cellIt = contextCellIDs.begin(); cellIt != contextCellIDs.end(); cellIt++)
{
GlobalIndexType cellID = *cellIt;
if (_cellIDs.find(cellID) == _cellIDs.end())
{
// clear out the associated entries
for (int j=0; j<numEntriesPerCell; j++)
{
values[cellIndex*numEntriesPerCell + j] = 0;
}
}
cellIndex++;
}
}
void values(FieldContainer<double> &values, BasisCachePtr basisCache)
{
CHECK_VALUES_RANK(values);
values.initialize(_a);
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// This little trick lets us print to std::cout only if
// a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
// Save the format state of the original std::cout.
Teuchos::oblackholestream oldFormatState;
oldFormatState.copyfmt(std::cout);
*outStream \
<< "===============================================================================\n" \
<< "| |\n" \
<< "| Unit Test (Basis_HGRAD_TET_COMP12_FEM) |\n" \
<< "| |\n" \
<< "| 1) Evaluation of Basis Function Values |\n" \
<< "| |\n" \
<< "| Questions? Contact Pavel Bochev ([email protected]), |\n" \
<< "| Denis Ridzal ([email protected]), |\n" \
<< "| Kara Peterson ([email protected]), |\n" \
<< "| Jake Ostien ([email protected]). |\n" \
<< "| |\n" \
<< "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n" \
<< "| Trilinos website: http://trilinos.sandia.gov |\n" \
<< "| |\n" \
<< "===============================================================================\n"\
<< "| TEST 1: Basis creation, values |\n"\
<< "===============================================================================\n";
// Define basis and error flag
Basis_HGRAD_TET_COMP12_FEM<double, FieldContainer<double> > tetBasis;
int errorFlag = 0;
// Initialize throw counter for exception testing
//int nException = 0;
//int throwCounter = 0;
// Define array containing the 10 vertices of the reference TET
FieldContainer<double> tetNodes(10, 3);
tetNodes(0,0) = 0.0; tetNodes(0,1) = 0.0; tetNodes(0,2) = 0.0;
tetNodes(1,0) = 1.0; tetNodes(1,1) = 0.0; tetNodes(1,2) = 0.0;
tetNodes(2,0) = 0.0; tetNodes(2,1) = 1.0; tetNodes(2,2) = 0.0;
tetNodes(3,0) = 0.0; tetNodes(3,1) = 0.0; tetNodes(3,2) = 1.0;
tetNodes(4,0) = 0.5; tetNodes(4,1) = 0.0; tetNodes(4,2) = 0.0;
tetNodes(5,0) = 0.5; tetNodes(5,1) = 0.5; tetNodes(5,2) = 0.0;
tetNodes(6,0) = 0.0; tetNodes(6,1) = 0.5; tetNodes(6,2) = 0.0;
tetNodes(7,0) = 0.0; tetNodes(7,1) = 0.0; tetNodes(7,2) = 0.5;
tetNodes(8,0) = 0.5; tetNodes(8,1) = 0.0; tetNodes(8,2) = 0.5;
tetNodes(9,0) = 0.0; tetNodes(9,1) = 0.5; tetNodes(9,2) = 0.5;
// Define array containing 5 integration points
FieldContainer<double> tetPoints(9, 3);
// from the 5 point integration
tetPoints(0,0) = 0.25; tetPoints(0,1) = 0.25; tetPoints(0,2) = 0.25;
tetPoints(1,0) = 0.5; tetPoints(1,1) = (1./6.); tetPoints(1,2) = (1./6.);
tetPoints(2,0) = (1./6.); tetPoints(2,1) = 0.5; tetPoints(2,2) = (1./6.);
tetPoints(3,0) = (1./6.); tetPoints(3,1) = (1./6.); tetPoints(3,2) = 0.5;
tetPoints(4,0) = (1./6.); tetPoints(4,1) = (1./6.); tetPoints(4,2) = (1./6.);
// from the 4 point integration
tetPoints(5,0) = 0.1381966011250105151795413165634361882280;
tetPoints(5,1) = 0.1381966011250105151795413165634361882280;
tetPoints(5,2) = 0.1381966011250105151795413165634361882280;
tetPoints(6,0) = 0.5854101966249684544613760503096914353161;
tetPoints(6,1) = 0.1381966011250105151795413165634361882280;
tetPoints(6,2) = 0.1381966011250105151795413165634361882280;
tetPoints(7,0) = 0.1381966011250105151795413165634361882280;
tetPoints(7,1) = 0.5854101966249684544613760503096914353161;
tetPoints(7,2) = 0.1381966011250105151795413165634361882280;
tetPoints(8,0) = 0.1381966011250105151795413165634361882280;
tetPoints(8,1) = 0.1381966011250105151795413165634361882280;
tetPoints(8,2) = 0.5854101966249684544613760503096914353161;
// output precision
outStream -> precision(20);
// VALUE: Each row gives the 10 correct basis set values at an evaluation point
double nodalBasisValues[] = {
// first 4 vertices
1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
// second 6 vertices
0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0
};
double pointBasisValues[] = {
// pt 0 {0.25, 0.25, 0.25}
0.0, 0.0, 0.0, 0.0, 1./6., 1./6., 1./6., 1./6., 1./6., 1./6.,
// pt 1 {0.5, 1/6, 1/6}
0.0, 0.0, 0.0, 0.0, 1./3., 1./3., 0.0, 0.0, 1./3., 0.0,
// pt 2 {1/6, 0.5, 0.1/6}
0.0, 0.0, 0.0, 0.0, 0.0, 1./3., 1./3., 0.0, 0.0, 1./3.,
// pt 3 {1/6, 1/6, 0.5}
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1./3., 1./3., 1./3.,
// pt 4 {1/6, 1/6, 1/6}
0.0, 0.0, 0.0, 0.0, 1./3., 0.0, 1./3., 1./3., 0.0, 0.0,
// pt 5
0.170820393249936908922752100619382870632, 0.0, 0.0, 0.0, 0.276393202250021030359082633126872376456, 0.0, 0.276393202250021030359082633126872376456, 0.276393202250021030359082633126872376456, 0.0, 0.0,
// pt 6
0.0, 0.170820393249936908922752100619382870632, 0.0, 0.0, 0.276393202250021030359082633126872376456, 0.276393202250021030359082633126872376456, 0.0, 0.0, 0.276393202250021030359082633126872376456, 0.0,
// pt 7
0.0, 0.0, 0.170820393249936908922752100619382870632, 0.0, 0.0, 0.276393202250021030359082633126872376456, 0.276393202250021030359082633126872376456, 0.0, 0.0, 0.276393202250021030359082633126872376456,
// pt 8
0.0, 0.0, 0.0, 0.170820393249936908922752100619382870632, 0.0, 0.0, 0.0, 0.276393202250021030359082633126872376456, 0.276393202250021030359082633126872376456, 0.276393202250021030359082633126872376456,
};
// GRAD and D1: each row gives the 3x10 correct values of the gradients of the 10 basis functions
double pointBasisGrads[] = {
// point 0
-1./4., -1./4., -1./4., \
1./4., 0.0, 0.0, \
0.0, 1./4., 0.0, \
0.0, 0.0, 1./4., \
0.0, -3./4., -3./4., \
3./4., 3./4., 0.0, \
-3./4., 0.0, -3./4., \
-3./4., -3./4., 0.0, \
3./4., 0.0, 3./4., \
0.0, 3./4., 3./4., \
// point 1
-1./24., -1./24., -1./24., \
7./8., 0.0, 0.0, \
0.0, 1./24., 0.0, \
0.0, 0.0, 1./24., \
-35./36., -19./12., -19./12., \
11./18., 19./12., 0.0, \
-17./36., 0.0, -1./3., \
-17./36., -1./3., 0.0, \
11./18., 0.0, 19./12., \
-5./36., 1./3., 1./3., \
// point 2
-1./24., -1./24., -1./24., \
1./24., 0.0, 0.0, \
0.0, 7./8., 0.0, \
0.0, 0.0, 1./24., \
0.0, -17./36., -1./3., \
19./12., 11./18., 0.0, \
-19./12., -35./36., -19./12., \
-1./3., -17./36., 0.0, \
1./3., -5./36., 1./3., \
0.0, 11./18., 19./12., \
// point 3
-1./24., -1./24., -1./24., \
1./24., 0.0, 0.0, \
0.0, 1./24., 0.0, \
0.0, 0.0, 7./8., \
0.0, -1./3., -17./36., \
1./3., 1./3., -5./36., \
-1./3., 0.0, -17./36., \
-19./12., -19./12., -35./36., \
19./12., 0.0, 11./18., \
0.0, 19./12., 11./18., \
// point 4
-7./8., -7./8., -7./8., \
1./24., 0.0, 0.0, \
0.0, 1./24., 0.0, \
0.0, 0.0, 1./24., \
35./36., -11./18., -11./18., \
17./36., 17./36., 5./36., \
-11./18., 35./36., -11./18., \
-11./18., -11./18., 35./36., \
17./36., 5./36., 17./36., \
5./36., 17./36., 17./36., \
// point 5
-1.088525491562421136153440125774228588290, -1.088525491562421136153440125774228588290, -1.088525491562421136153440125774228588290, \
-0.029508497187473712051146708591409529430, 0.0, 0.0, \
0.0, -0.029508497187473712051146708591409529430, 0.0, \
0.0, 0.0, -0.029508497187473712051146708591409529430, \
1.30437298687487732290535130675991113734, -0.563661001875017525299235527605726980380, -0.563661001875017525299235527605726980380, \
0.377322003750035050598471055211453960760, 0.377322003750035050598471055211453960760, 0.186338998124982474700764472394273019620, \
-0.563661001875017525299235527605726980380, 1.30437298687487732290535130675991113734, -0.563661001875017525299235527605726980380, \
-0.563661001875017525299235527605726980380, -0.563661001875017525299235527605726980380, 1.30437298687487732290535130675991113734, \
0.377322003750035050598471055211453960760, 0.186338998124982474700764472394273019620, 0.377322003750035050598471055211453960760, \
0.186338998124982474700764472394273019620, 0.377322003750035050598471055211453960760, 0.377322003750035050598471055211453960760, \
// point 6
0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, \
1.088525491562421136153440125774228588290, 0.0, 0.0, \
0.0, -0.029508497187473712051146708591409529430, 0.0, \
0.0, 0.0, -0.029508497187473712051146708591409529430, \
-1.30437298687487732290535130675991113734, -1.868033988749894848204586834365638117720, -1.868033988749894848204586834365638117720, \
0.563661001875017525299235527605726980380, 1.868033988749894848204586834365638117720, 0.0, \
-0.377322003750035050598471055211453960760, 0.0, -0.190983005625052575897706582817180941140, \
-0.377322003750035050598471055211453960760, -0.190983005625052575897706582817180941140, 0.0, \
0.563661001875017525299235527605726980380, 0.0, 1.868033988749894848204586834365638117720, \
-0.186338998124982474700764472394273019620, 0.190983005625052575897706582817180941140, 0.19098300562505257589770658281718094114, \
// point 7
0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, \
-0.029508497187473712051146708591409529430, 0.0, 0.0, \
0.0, 1.088525491562421136153440125774228588290, 0.0, \
0.0, 0.0, -0.029508497187473712051146708591409529430, \
0.0, -0.377322003750035050598471055211453960760, -0.190983005625052575897706582817180941140, \
1.868033988749894848204586834365638117720, 0.563661001875017525299235527605726980380, 0.0, \
-1.868033988749894848204586834365638117720, -1.30437298687487732290535130675991113734, -1.868033988749894848204586834365638117720, \
-0.190983005625052575897706582817180941140, -0.377322003750035050598471055211453960760, 0.0, \
0.190983005625052575897706582817180941140, -0.186338998124982474700764472394273019620, 0.190983005625052575897706582817180941140, \
0.0, 0.563661001875017525299235527605726980380, 1.868033988749894848204586834365638117720, \
// point 8
0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, 0.029508497187473712051146708591409529430, \
-0.029508497187473712051146708591409529430, 0.0, 0.0, \
0.0, -0.029508497187473712051146708591409529430, 0.0, \
0.0, 0.0, 1.088525491562421136153440125774228588290, \
0.0, -0.190983005625052575897706582817180941140, -0.377322003750035050598471055211453960760, \
0.190983005625052575897706582817180941140, 0.190983005625052575897706582817180941140, -0.186338998124982474700764472394273019620, \
-0.190983005625052575897706582817180941140, 0.0, -0.377322003750035050598471055211453960760, \
-1.868033988749894848204586834365638117720, -1.868033988749894848204586834365638117720, -1.30437298687487732290535130675991113734,
1.868033988749894848204586834365638117720, 0.0, 0.563661001875017525299235527605726980380, \
0.0, 1.868033988749894848204586834365638117720, 0.563661001875017525299235527605726980380, \
};
try{
// Dimensions for the output arrays:
int numFields = tetBasis.getCardinality();
int numNodes = tetNodes.dimension(0);
int spaceDim = tetBasis.getBaseCellTopology().getDimension();
// Generic array for values, grads, curls, etc. that will be properly sized before each call
FieldContainer<double> vals;
// Check VALUE of basis functions at nodes: resize vals to rank-2 container:\n";
*outStream << " check VALUE of basis functions at nodes\n";
vals.resize(numFields, numNodes);
tetBasis.getValues(vals, tetNodes, OPERATOR_VALUE);
for (int i = 0; i < numFields; i++) {
for (int j = 0; j < numNodes; j++) {
int l = i + j * numFields;
if (std::abs(vals(i,j) - nodalBasisValues[l]) > INTREPID_TOL) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";
*outStream << "} computed value: " << vals(i,j)
<< " but reference value: " << nodalBasisValues[l] << "\n";
}
}
}
// Check VALUE of basis functions at points: resize vals to rank-2 container:\n";
*outStream << " check VALUE of basis functions at points\n";
int numPoints = tetPoints.dimension(0);
vals.resize(numFields, numPoints);
vals.initialize(0.0);
tetBasis.getValues(vals, tetPoints, OPERATOR_VALUE);
for (int i = 0; i < numFields; i++) {
for (int j = 0; j < numPoints; j++) {
int l = i + j * numFields;
if (std::abs(vals(i,j) - pointBasisValues[l]) > INTREPID_TOL) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";
*outStream << "} computed value: " << vals(i,j)
<< " but reference value: " << pointBasisValues[l] << "\n";
}
}
}
// Check VALUE of basis functions at random points: resize vals to rank-2 container:\n";
*outStream << " check VALUE of basis functions at random points\n";
int numRandomPoints = 16384;
FieldContainer<double> tetRandomPoints(numRandomPoints, 3);
vals.resize(numFields, numRandomPoints);
vals.initialize(0.0);
int point = 0;
int count = 0;
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(0, 1);
while (point < numRandomPoints) {
count++;
double r = dis(gen);
double s = dis(gen);
double t = dis(gen);
if (r + s + t > 1.0) continue;
tetRandomPoints(point, 0) = r;
tetRandomPoints(point, 1) = s;
tetRandomPoints(point, 2) = t;
point++;
}
tetBasis.getValues(vals, tetRandomPoints, OPERATOR_VALUE);
for (int j = 0; j < numRandomPoints; j++) {
double sum = 0.0;
for (int i = 0; i < numFields; i++) {
sum += vals(i,j);
}
if (std::abs(sum - 1.0) > INTREPID_TOL) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Just indicate something bad happened
*outStream << " Composite tet basis functions";
*outStream << " are not summing to 1.0\n";
*outStream << " sum : " << sum << "\n";
}
}
// Check GRAD of basis functions at points: resize vals to rank-3 container:\n";
numPoints = tetPoints.dimension(0);
vals.resize(numFields, numPoints, spaceDim);
vals.initialize(0.0);
tetBasis.getValues(vals, tetPoints, OPERATOR_GRAD);
for (int i = 0; i < numFields; i++) {
for (int j = 0; j < numPoints; j++) {
for (int k = 0; k < spaceDim; k++) {
int l = k + i * spaceDim + j * spaceDim * numFields;
if (std::abs(vals(i,j,k) - pointBasisGrads[l]) > INTREPID_TOL) {
errorFlag++;
*outStream << std::setw(70) << "^^^^----FAILURE!" << "\n";
// Output the multi-index of the value where the error is:
*outStream << " At multi-index { ";
*outStream << i << " ";*outStream << j << " ";*outStream << k << " ";
*outStream << "} computed grad component: " << vals(i,j,k)
<< " but reference grad component: " << pointBasisGrads[l] << "\n";
}
}
}
}
}
// Catch unexpected errors
catch (std::logic_error err) {
*outStream << err.what() << "\n\n";
errorFlag = -1000;
};
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
// reset format state of std::cout
std::cout.copyfmt(oldFormatState);
return errorFlag;
}
void Projector::projectFunctionOntoBasisInterpolating(FieldContainer<double> &basisCoefficients, FunctionPtr fxn,
BasisPtr basis, BasisCachePtr domainBasisCache) {
basisCoefficients.initialize(0);
CellTopoPtr domainTopo = basis->domainTopology();
unsigned domainDim = domainTopo->getDimension();
IPPtr ip;
bool traceVar = domainBasisCache->isSideCache();
pair<IPPtr, VarPtr> ipVarPair = IP::standardInnerProductForFunctionSpace(basis->functionSpace(), traceVar, domainDim);
ip = ipVarPair.first;
VarPtr v = ipVarPair.second;
IPPtr ip_l2 = Teuchos::rcp( new IP );
ip_l2->addTerm(v);
// for now, make all projections use L^2... (having some issues with gradients and cell Jacobians--I think we need the restriction of the cell Jacobian to the subcell, e.g., and it's not clear how to do that...)
ip = ip_l2;
FieldContainer<double> referenceDomainNodes(domainTopo->getVertexCount(),domainDim);
CamelliaCellTools::refCellNodesForTopology(referenceDomainNodes, domainTopo);
int basisCardinality = basis->getCardinality();
set<int> allDofs;
for (int i=0; i<basisCardinality; i++) {
allDofs.insert(i);
}
for (int d=0; d<=domainDim; d++) {
FunctionPtr projectionThusFar = NewBasisSumFunction::basisSumFunction(basis, basisCoefficients);
FunctionPtr fxnToApproximate = fxn - projectionThusFar;
int subcellCount = domainTopo->getSubcellCount(d);
for (int subcord=0; subcord<subcellCount; subcord++) {
set<int> subcellDofOrdinals = basis->dofOrdinalsForSubcell(d, subcord);
if (subcellDofOrdinals.size() > 0) {
FieldContainer<double> refCellPoints;
FieldContainer<double> cubatureWeightsSubcell; // allows us to integrate over the fine subcell even when domain is higher-dimensioned
if (d == 0) {
refCellPoints.resize(1,domainDim);
for (int d1=0; d1<domainDim; d1++) {
refCellPoints(0,d1) = referenceDomainNodes(subcord,d1);
}
cubatureWeightsSubcell.resize(1);
cubatureWeightsSubcell(0) = 1.0;
} else {
CellTopoPtr subcellTopo = domainTopo->getSubcell(d, subcord);
// Teuchos::RCP<Cubature<double> > subcellCubature = cubFactory.create(subcellTopo, domainBasisCache->cubatureDegree());
BasisCachePtr subcellCache = Teuchos::rcp( new BasisCache(subcellTopo, domainBasisCache->cubatureDegree(), false) );
int numPoints = subcellCache->getRefCellPoints().dimension(0);
refCellPoints.resize(numPoints,domainDim);
cubatureWeightsSubcell = subcellCache->getCubatureWeights();
if (d == domainDim) {
refCellPoints = subcellCache->getRefCellPoints();
} else {
CamelliaCellTools::mapToReferenceSubcell(refCellPoints, subcellCache->getRefCellPoints(), d,
subcord, domainTopo);
}
}
domainBasisCache->setRefCellPoints(refCellPoints, cubatureWeightsSubcell);
IPPtr ipForProjection = (d==0) ? ip_l2 : ip; // just use values at vertices (ignore derivatives)
set<int> dofsToSkip = allDofs;
for (set<int>::iterator dofOrdinalIt=subcellDofOrdinals.begin(); dofOrdinalIt != subcellDofOrdinals.end(); dofOrdinalIt++) {
dofsToSkip.erase(*dofOrdinalIt);
}
FieldContainer<double> newBasisCoefficients;
projectFunctionOntoBasis(newBasisCoefficients, fxnToApproximate, basis, domainBasisCache, ipForProjection, v, dofsToSkip);
for (int cellOrdinal=0; cellOrdinal<newBasisCoefficients.dimension(0); cellOrdinal++) {
for (set<int>::iterator dofOrdinalIt=subcellDofOrdinals.begin(); dofOrdinalIt != subcellDofOrdinals.end(); dofOrdinalIt++) {
basisCoefficients(cellOrdinal,*dofOrdinalIt) = newBasisCoefficients(cellOrdinal,*dofOrdinalIt);
}
}
}
}
}
}
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 BilinearFormUtility::computeOptimalStiffnessMatrix(FieldContainer<double> &stiffness,
FieldContainer<double> &optimalTestWeights,
BilinearFormPtr bilinearForm,
Teuchos::RCP<DofOrdering> trialOrdering, Teuchos::RCP<DofOrdering> testOrdering,
shards::CellTopology &cellTopo, FieldContainer<double> &physicalCellNodes,
FieldContainer<double> &cellSideParities) {
// lots of code copied and pasted from the very similar computeStiffnessMatrix. The difference here is that for each optimal test function,
// we need to ask the bilinear form about each of its components (it's a vector whereas the other guy had just a single basis function
// for each...), and then apply the appropriate weights....
// physicalCellNodes: the nodal points for the element(s) with topology cellTopo
// The dimensions are (numCells, numNodesPerElement, spaceDimension)
// optimalTestWeights dimensions are: (numCells, numTrial, numTest) -- numTrial is the optTest index
// stiffness dimensions are: (numCells, # trialOrdering Dofs, # trialOrdering Dofs)
// (while (cell,trial,test) is more natural conceptually, I believe the above ordering makes
// more sense given the inversion that we must do to compute the optimal test functions...)
// steps:
// 0. Set up BasisCache
// 3. For each (test, trial) combination:
// a. Apply the specified operators to the basis in the DofOrdering, at the cubature points
// b. Multiply the two bases together, weighted with Jacobian/Piola transform and cubature weights
// c. Pass the result to bilinearForm's applyBilinearFormData method
// d. Sum up (integrate) and place in stiffness matrix according to DofOrdering indices
// 0. Set up Cubature
unsigned numCells = physicalCellNodes.dimension(0);
unsigned numNodesPerElem = physicalCellNodes.dimension(1);
unsigned spaceDim = physicalCellNodes.dimension(2);
// Check that cellTopo and physicalCellNodes agree
TEUCHOS_TEST_FOR_EXCEPTION( ( numNodesPerElem != cellTopo.getNodeCount() ),
std::invalid_argument,
"Second dimension of physicalCellNodes and cellTopo.getNodeCount() do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( spaceDim != cellTopo.getDimension() ),
std::invalid_argument,
"Third dimension of physicalCellNodes and cellTopo.getDimension() do not match.");
int numOptTestFunctions = optimalTestWeights.dimension(1); // should also == numTrialDofs
TEUCHOS_TEST_FOR_EXCEPTION( ( optimalTestWeights.dimension(1) != stiffness.dimension(2) ),
std::invalid_argument,
"optimalTestWeights.dimension(1) (=" << optimalTestWeights.dimension(1) << ") and stiffness.dimension(2) (=" << stiffness.dimension(2) << ") do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( stiffness.dimension(1) != stiffness.dimension(2) ),
std::invalid_argument,
"stiffness.dimension(1) (=" << stiffness.dimension(1) << ") and stiffness.dimension(2) (=" << stiffness.dimension(2) << ") do not match.");
// Set up BasisCache
int cubDegreeTrial = trialOrdering->maxBasisDegree();
int cubDegreeTest = testOrdering->maxBasisDegree();
int cubDegree = cubDegreeTrial + cubDegreeTest;
BasisCache basisCache(physicalCellNodes, cellTopo, *trialOrdering, cubDegreeTest, true); // DO create side caches, too
unsigned numSides = CamelliaCellTools::getSideCount(cellTopo);
vector<int> testIDs = bilinearForm->testIDs();
vector<int>::iterator testIterator;
vector<int> trialIDs = bilinearForm->trialIDs();
vector<int>::iterator trialIterator;
BasisPtr trialBasis,testBasis;
stiffness.initialize(0.0);
for (trialIterator = trialIDs.begin(); trialIterator != trialIDs.end(); trialIterator++) {
int trialID = *trialIterator;
for (int optTestIndex=0; optTestIndex < numOptTestFunctions; optTestIndex++) {
FieldContainer<double> weights(numCells,testOrdering->totalDofs());
for (unsigned i=0; i<numCells; i++) {
for (int j=0; j<testOrdering->totalDofs(); j++) {
weights(i,j) = optimalTestWeights(i,optTestIndex,j);
}
}
for (testIterator = testIDs.begin(); testIterator != testIDs.end(); testIterator++) {
int testID = *testIterator;
vector<EOperatorExtended> trialOperators, testOperators;
bilinearForm->trialTestOperators(trialID, testID, trialOperators, testOperators);
vector<EOperatorExtended>::iterator trialOpIt, testOpIt;
testOpIt = testOperators.begin();
int operatorIndex = -1;
for (trialOpIt = trialOperators.begin(); trialOpIt != trialOperators.end(); trialOpIt++) {
IntrepidExtendedTypes::EOperatorExtended trialOperator = *trialOpIt;
IntrepidExtendedTypes::EOperatorExtended testOperator = *testOpIt;
operatorIndex++;
if (testOperator==OP_TIMES_NORMAL) {
TEUCHOS_TEST_FOR_EXCEPTION(true,std::invalid_argument,"OP_TIMES_NORMAL not supported for tests. Use for trial only");
}
Teuchos::RCP < const FieldContainer<double> > testValuesTransformed;
Teuchos::RCP < const FieldContainer<double> > trialValuesTransformed;
Teuchos::RCP < const FieldContainer<double> > testValuesTransformedWeighted;
if (! bilinearForm->isFluxOrTrace(trialID)) {
trialBasis = trialOrdering->getBasis(trialID);
testBasis = testOrdering->getBasis(testID);
FieldContainer<double> miniStiffness( numCells, testBasis->getCardinality(), trialBasis->getCardinality() );
trialValuesTransformed = basisCache.getTransformedValues(trialBasis,trialOperator);
testValuesTransformedWeighted = basisCache.getTransformedWeightedValues(testBasis,testOperator);
FieldContainer<double> physicalCubaturePoints = basisCache.getPhysicalCubaturePoints();
FieldContainer<double> materialDataAppliedToTrialValues = *trialValuesTransformed; // copy first
FieldContainer<double> materialDataAppliedToTestValues = *testValuesTransformedWeighted; // copy first
bilinearForm->applyBilinearFormData(materialDataAppliedToTrialValues,materialDataAppliedToTestValues,
trialID,testID,operatorIndex,physicalCubaturePoints);
int testDofOffset = testOrdering->getDofIndex(testID,0);
// note that weightCellBasisValues does depend on contiguous test basis dofs...
// (this is the plan, since there shouldn't be any kind of identification between different test dofs,
// especially since test functions live only inside the cell)
weightCellBasisValues(materialDataAppliedToTestValues, weights, testDofOffset);
FunctionSpaceTools::integrate<double>(miniStiffness,materialDataAppliedToTestValues,materialDataAppliedToTrialValues,COMP_BLAS);
// place in the appropriate spot in the element-stiffness matrix
// copy goes from (cell,trial_basis_dof,test_basis_dof) to (cell,element_trial_dof,element_test_dof)
// there may be a more efficient way to do this copying:
// (one strategy would be to reimplement fst::integrate to support offsets, so that no copying needs to be done...)
for (int i=0; i < testBasis->getCardinality(); i++) {
for (int j=0; j < trialBasis->getCardinality(); j++) {
int trialDofIndex = trialOrdering->getDofIndex(trialID,j);
for (unsigned k=0; k < numCells; k++) {
stiffness(k,optTestIndex,trialDofIndex) += miniStiffness(k,i,j);
}
}
}
} else { // boundary integral
int trialBasisRank = trialOrdering->getBasisRank(trialID);
int testBasisRank = testOrdering->getBasisRank(testID);
TEUCHOS_TEST_FOR_EXCEPTION( ( trialBasisRank != 0 ),
std::invalid_argument,
"Boundary trial variable (flux or trace) given with non-scalar basis. Unsupported.");
bool isFlux = false; // i.e. the normal is "folded into" the variable definition, so that we must take parity into account
const set<int> normalOperators = BilinearForm::normalOperators();
if ( (normalOperators.find(testOperator) == normalOperators.end() )
&& (normalOperators.find(trialOperator) == normalOperators.end() ) ) {
// normal not yet taken into account -- so it must be "hidden" in the trial variable
isFlux = true;
}
for (unsigned sideOrdinal=0; sideOrdinal<numSides; sideOrdinal++) {
trialBasis = trialOrdering->getBasis(trialID,sideOrdinal);
testBasis = testOrdering->getBasis(testID);
FieldContainer<double> miniStiffness( numCells, testBasis->getCardinality(), trialBasis->getCardinality() );
// for trial: we never dot with normal, and the value lives on the side, so we don't use the volume coords either:
trialValuesTransformed = basisCache.getTransformedValues(trialBasis,trialOperator,sideOrdinal,false);
// for test: first, don't dot with normal, but do use the volume coords:
//testValuesTransformed = basisCache.getTransformedValues(testBasis,testOperator,sideOrdinal,true);
testValuesTransformedWeighted = basisCache.getTransformedWeightedValues(testBasis,testOperator,sideOrdinal,true);
// copy before manipulating trialValues--these are the ones stored in the cache, so we're not allowed to change them!!
FieldContainer<double> materialDataAppliedToTrialValues = *trialValuesTransformed;
if (isFlux) {
// this being a flux ==> take cell parity into account (because then there must be a normal folded into the flux definition)
// we need to multiply the trialValues by the parity of the normal, since
// the trial implicitly contains an outward normal, and we need to adjust for the fact
// that the neighboring cells have opposite normal
// trialValues should have dimensions (numCells,numFields,numCubPointsSide)
int numFields = trialValuesTransformed->dimension(1);
int numPoints = trialValuesTransformed->dimension(2);
for (unsigned cellIndex=0; cellIndex<numCells; cellIndex++) {
double parity = cellSideParities(cellIndex,sideOrdinal);
if (parity != 1.0) { // otherwise, we can just leave things be...
for (int fieldIndex=0; fieldIndex<numFields; fieldIndex++) {
for (int ptIndex=0; ptIndex<numPoints; ptIndex++) {
materialDataAppliedToTrialValues(cellIndex,fieldIndex,ptIndex) *= parity;
}
}
}
}
}
FieldContainer<double> cubPointsSidePhysical = basisCache.getPhysicalCubaturePointsForSide(sideOrdinal);
FieldContainer<double> materialDataAppliedToTestValues = *testValuesTransformedWeighted; // copy first
bilinearForm->applyBilinearFormData(materialDataAppliedToTrialValues,materialDataAppliedToTestValues,
trialID,testID,operatorIndex,cubPointsSidePhysical);
int testDofOffset = testOrdering->getDofIndex(testID,0,0);
weightCellBasisValues(materialDataAppliedToTestValues, weights, testDofOffset);
// d. Sum up (integrate) and place in stiffness matrix according to DofOrdering indices
FunctionSpaceTools::integrate<double>(miniStiffness,materialDataAppliedToTestValues,materialDataAppliedToTrialValues,COMP_BLAS);
// place in the appropriate spot in the element-stiffness matrix
// copy goes from (cell,trial_basis_dof,test_basis_dof) to (cell,element_trial_dof,element_test_dof)
for (int i=0; i < testBasis->getCardinality(); i++) {
for (int j=0; j < trialBasis->getCardinality(); j++) {
int trialDofIndex = trialOrdering->getDofIndex(trialID,j,sideOrdinal);
for (unsigned k=0; k < numCells; k++) {
stiffness(k,optTestIndex,trialDofIndex) += miniStiffness(k,i,j);
}
}
}
}
}
testOpIt++;
}
}
}
}
}
void BilinearFormUtility::computeStiffnessMatrix(FieldContainer<double> &stiffness,
FieldContainer<double> &innerProductMatrix,
FieldContainer<double> &optimalTestWeights) {
// stiffness has dimensions (numCells, numTrialDofs, numTrialDofs)
// innerProductMatrix has dim. (numCells, numTestDofs, numTestDofs)
// optimalTestWeights has dim. (numCells, numTrialDofs, numTestDofs)
// all this does is computes stiffness = weights^T * innerProductMatrix * weights
int numCells = stiffness.dimension(0);
int numTrialDofs = stiffness.dimension(1);
int numTestDofs = innerProductMatrix.dimension(1);
// check that all the dimensions are compatible:
TEUCHOS_TEST_FOR_EXCEPTION( ( optimalTestWeights.dimension(0) != numCells ),
std::invalid_argument,
"stiffness.dimension(0) and optimalTestWeights.dimension(0) (numCells) do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( optimalTestWeights.dimension(1) != numTrialDofs ),
std::invalid_argument,
"numTrialDofs and optimalTestWeights.dimension(1) do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( optimalTestWeights.dimension(2) != numTestDofs ),
std::invalid_argument,
"numTestDofs and optimalTestWeights.dimension(2) do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( innerProductMatrix.dimension(2) != innerProductMatrix.dimension(1) ),
std::invalid_argument,
"innerProductMatrix.dimension(1) and innerProductMatrix.dimension(2) do not match.");
TEUCHOS_TEST_FOR_EXCEPTION( ( stiffness.dimension(1) != stiffness.dimension(2) ),
std::invalid_argument,
"stiffness.dimension(1) and stiffness.dimension(2) do not match.");
stiffness.initialize(0);
for (int cellIndex=0; cellIndex < numCells; cellIndex++) {
Epetra_SerialDenseMatrix weightsT(Copy,
&optimalTestWeights(cellIndex,0,0),
optimalTestWeights.dimension(2), // stride
optimalTestWeights.dimension(2),optimalTestWeights.dimension(1));
Epetra_SerialDenseMatrix ipMatrixT(Copy,
&innerProductMatrix(cellIndex,0,0),
innerProductMatrix.dimension(2), // stride
innerProductMatrix.dimension(2),innerProductMatrix.dimension(1));
Epetra_SerialDenseMatrix stiffT (View,
&stiffness(cellIndex,0,0),
stiffness.dimension(2), // stride
stiffness.dimension(2),stiffness.dimension(1));
Epetra_SerialDenseMatrix intermediate( numTrialDofs, numTestDofs );
// account for the fact that SDM is column-major and FC is row-major:
// (weightsT) * (ipMatrixT)^T * (weightsT)^T
int success = intermediate.Multiply('T','T',1.0,weightsT,ipMatrixT,0.0);
if (success != 0) {
cout << "computeStiffnessMatrix: intermediate.Multiply() failed with error code " << success << endl;
}
success = stiffT.Multiply('N','N',1.0,intermediate,weightsT,0.0);
// stiffT is technically the transpose of stiffness, but the construction A^T * B * A is symmetric even in general...
if (success != 0) {
cout << "computeStiffnessMatrix: stiffT.Multiply() failed with error code " << success << endl;
}
}
if ( ! checkForZeroRowsAndColumns("stiffness",stiffness) ) {
//cout << "stiffness: " << stiffness;
}
bool enforceNumericalSymmetry = false;
if (enforceNumericalSymmetry) {
for (unsigned int c=0; c < numCells; c++)
for (unsigned int i=0; i < numTrialDofs; i++)
for (unsigned int j=i+1; j < numTrialDofs; j++)
{
stiffness(c,i,j) = (stiffness(c,i,j) + stiffness(c,j,i)) / 2.0;
stiffness(c,j,i) = stiffness(c,i,j);
}
}
}
void Boundary::bcsToImpose(FieldContainer<GlobalIndexType> &globalIndices,
FieldContainer<Scalar> &globalValues, TBC<Scalar> &bc,
DofInterpreter* dofInterpreter)
{
set< GlobalIndexType > rankLocalCells = _mesh->cellIDsInPartition();
map< GlobalIndexType, double> bcGlobalIndicesAndValues;
for (GlobalIndexType cellID : rankLocalCells)
{
bcsToImpose(bcGlobalIndicesAndValues, bc, cellID, dofInterpreter);
}
singletonBCsToImpose(bcGlobalIndicesAndValues, bc, dofInterpreter);
// ****** New, tag-based BC imposition follows ******
map< GlobalIndexType, double> bcTagGlobalIndicesAndValues;
map< int, vector<pair<VarPtr, TFunctionPtr<Scalar>>>> tagBCs = bc.getDirichletTagBCs(); // keys are tags
MeshTopology* meshTopo = dynamic_cast<MeshTopology*>(_mesh->getTopology().get());
TEUCHOS_TEST_FOR_EXCEPTION(!meshTopo, std::invalid_argument, "pure MeshTopologyViews are not yet supported by new tag-based BC imposition");
for (auto tagBC : tagBCs)
{
int tagID = tagBC.first;
vector<EntitySetPtr> entitySets = meshTopo->getEntitySetsForTagID(DIRICHLET_SET_TAG_NAME, tagID);
for (EntitySetPtr entitySet : entitySets)
{
// get rank-local cells that match the entity set:
set<IndexType> matchingCellIDs = entitySet->cellIDsThatMatch(_mesh->getTopology(), rankLocalCells);
for (IndexType cellID : matchingCellIDs)
{
ElementTypePtr elemType = _mesh->getElementType(cellID);
BasisCachePtr basisCache = BasisCache::basisCacheForCell(_mesh, cellID);
for (auto varFunctionPair : tagBC.second)
{
VarPtr var = varFunctionPair.first;
FunctionPtr f = varFunctionPair.second;
vector<int> sideOrdinals = elemType->trialOrderPtr->getSidesForVarID(var->ID());
for (int sideOrdinal : sideOrdinals)
{
BasisPtr basis = elemType->trialOrderPtr->getBasis(var->ID(), sideOrdinal);
bool isVolume = basis->domainTopology()->getDimension() == _mesh->getDimension();
for (int d=0; d<_mesh->getDimension(); d++)
{
vector<unsigned> matchingSubcells;
if (isVolume)
matchingSubcells = entitySet->subcellOrdinals(_mesh->getTopology(), cellID, d);
else
{
CellTopoPtr cellTopo = elemType->cellTopoPtr;
int sideDim = cellTopo->getDimension() - 1;
vector<unsigned> matchingSubcellsOnSide = entitySet->subcellOrdinalsOnSide(_mesh->getTopology(), cellID, sideOrdinal, d);
for (unsigned sideSubcellOrdinal : matchingSubcellsOnSide)
{
unsigned cellSubcellOrdinal = CamelliaCellTools::subcellOrdinalMap(cellTopo, sideDim, sideOrdinal, d, sideSubcellOrdinal);
matchingSubcells.push_back(cellSubcellOrdinal);
}
}
if (matchingSubcells.size() == 0) continue; // nothing to impose
/*
What follows - projecting the function onto the basis on the whole domain - is more expensive than necessary,
in the general case: we can do the projection on just the matching subcells, and if we had a way of taking the
restriction of a basis to a subcell of the domain, then we could avoid computing the whole basis as well.
But for now, this should work, and it's simple to implement.
*/
BasisCachePtr basisCacheForImposition = isVolume ? basisCache : basisCache->getSideBasisCache(sideOrdinal);
int numCells = 1;
FieldContainer<double> basisCoefficients(numCells,basis->getCardinality());
Projector<double>::projectFunctionOntoBasisInterpolating(basisCoefficients, f, basis, basisCacheForImposition);
basisCoefficients.resize(basis->getCardinality());
set<GlobalIndexType> matchingGlobalIndices;
for (unsigned matchingSubcell : matchingSubcells)
{
set<GlobalIndexType> subcellGlobalIndices = dofInterpreter->globalDofIndicesForVarOnSubcell(var->ID(),cellID,d,matchingSubcell);
matchingGlobalIndices.insert(subcellGlobalIndices.begin(),subcellGlobalIndices.end());
}
FieldContainer<double> globalData;
FieldContainer<GlobalIndexType> globalDofIndices;
// dofInterpreter->interpretLocalBasisCoefficients(cellID, var->ID(), sideOrdinal, basisCoefficientsToImpose, globalData, globalDofIndices);
dofInterpreter->interpretLocalBasisCoefficients(cellID, var->ID(), sideOrdinal, basisCoefficients, globalData, globalDofIndices);
for (int globalDofOrdinal=0; globalDofOrdinal<globalDofIndices.size(); globalDofOrdinal++)
{
GlobalIndexType globalDofIndex = globalDofIndices(globalDofOrdinal);
if (matchingGlobalIndices.find(globalDofIndex) != matchingGlobalIndices.end())
bcTagGlobalIndicesAndValues[globalDofIndex] = globalData(globalDofOrdinal);
}
}
}
}
}
}
}
// merge tag-based and legacy BC maps
double tol = 1e-15;
for (auto tagEntry : bcTagGlobalIndicesAndValues)
{
if (bcGlobalIndicesAndValues.find(tagEntry.first) != bcGlobalIndicesAndValues.end())
{
// then check that they match, within tolerance
double diff = abs(bcGlobalIndicesAndValues[tagEntry.first] - tagEntry.second);
TEUCHOS_TEST_FOR_EXCEPTION(diff > tol, std::invalid_argument, "Incompatible BC entries encountered");
}
else
{
bcGlobalIndicesAndValues[tagEntry.first] = tagEntry.second;
}
}
globalIndices.resize(bcGlobalIndicesAndValues.size());
globalValues.resize(bcGlobalIndicesAndValues.size());
globalIndices.initialize(0);
globalValues.initialize(0.0);
int entryOrdinal = 0;
for (auto bcEntry : bcGlobalIndicesAndValues)
{
globalIndices[entryOrdinal] = bcEntry.first;
globalValues[entryOrdinal] = bcEntry.second;
entryOrdinal++;
}
}
void ExactSolution::L2NormOfError(FieldContainer<double> &errorSquaredPerCell, Solution &solution, ElementTypePtr elemTypePtr, int trialID, int sideIndex, int cubDegree, double solutionLift) {
// BasisCache(ElementTypePtr elemType, Teuchos::RCP<Mesh> mesh = Teuchos::rcp( (Mesh*) NULL ), bool testVsTest=false, int cubatureDegreeEnrichment = 0)
DofOrdering dofOrdering = *(elemTypePtr->trialOrderPtr.get());
BasisPtr basis = dofOrdering.getBasis(trialID,sideIndex);
bool boundaryIntegral = solution.mesh()->bilinearForm()->isFluxOrTrace(trialID);
BasisCachePtr basisCache;
if (cubDegree <= 0) { // then take the default cub. degree
basisCache = Teuchos::rcp( new BasisCache( elemTypePtr, solution.mesh() ) );
} else {
// we could eliminate the logic below if we just added BasisCache::setCubatureDegree()...
// (the logic below is just to make the enriched cubature match the requested cubature degree...)
int maxTrialDegree;
if (!boundaryIntegral) {
maxTrialDegree = elemTypePtr->trialOrderPtr->maxBasisDegreeForVolume();
} else {
maxTrialDegree = elemTypePtr->trialOrderPtr->maxBasisDegree(); // generally, this will be the trace degree
}
int maxTestDegree = elemTypePtr->testOrderPtr->maxBasisDegree();
int cubDegreeEnrichment = max(cubDegree - (maxTrialDegree + maxTestDegree), 0);
basisCache = Teuchos::rcp( new BasisCache( elemTypePtr, solution.mesh(), false, cubDegreeEnrichment) );
}
// much of this code is the same as what's in the volume integration in computeStiffness...
FieldContainer<double> physicalCellNodes = solution.mesh()->physicalCellNodes(elemTypePtr);
vector<GlobalIndexType> cellIDs = solution.mesh()->cellIDsOfType(elemTypePtr);
basisCache->setPhysicalCellNodes(physicalCellNodes, cellIDs, true);
if (boundaryIntegral) {
basisCache = basisCache->getSideBasisCache(sideIndex);
}
FieldContainer<double> weightedMeasure = basisCache->getWeightedMeasures();
FieldContainer<double> weightedErrorSquared;
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numCubPoints = basisCache->getPhysicalCubaturePoints().dimension(1);
int spaceDim = basisCache->getPhysicalCubaturePoints().dimension(2);
Teuchos::Array<int> dimensions;
dimensions.push_back(numCells);
dimensions.push_back(numCubPoints);
int basisRank = BasisFactory::basisFactory()->getBasisRank(basis);
if (basisRank==1) {
dimensions.push_back(spaceDim);
}
FieldContainer<double> computedValues(dimensions);
FieldContainer<double> exactValues(dimensions);
if (solutionLift != 0.0) {
int size = computedValues.size();
for (int i=0; i<size; i++) {
computedValues[i] += solutionLift;
}
}
solution.solutionValues(computedValues, trialID, basisCache);
this->solutionValues(exactValues, trialID, basisCache);
// cout << "ExactSolution: exact values:\n" << exactValues;
// cout << "ExactSolution: computed values:\n" << computedValues;
FieldContainer<double> errorSquared(numCells,numCubPoints);
squaredDifference(errorSquared,computedValues,exactValues);
weightedErrorSquared.resize(numCells,numCubPoints);
for (int cellIndex=0; cellIndex<numCells; cellIndex++) {
for (int ptIndex=0; ptIndex<numCubPoints; ptIndex++) {
// following two lines for viewing in the debugger:
double weight = weightedMeasure(cellIndex,ptIndex);
double errorSquaredVal = errorSquared(cellIndex,ptIndex);
weightedErrorSquared(cellIndex,ptIndex) = errorSquared(cellIndex,ptIndex) * weightedMeasure(cellIndex,ptIndex);
}
}
// compute the integral
errorSquaredPerCell.initialize(0.0);
int numPoints = weightedErrorSquared.dimension(1);
for (int cellIndex=0; cellIndex<numCells; cellIndex++) {
for (int ptIndex=0; ptIndex<numPoints; ptIndex++) {
errorSquaredPerCell(cellIndex) += weightedErrorSquared(cellIndex,ptIndex);
}
}
}
