void BilinearFormUtility::weightCellBasisValues(FieldContainer<double> &basisValues, const FieldContainer<double> &weights, int offset) {
// weights are (numCells, offset+numFields)
// basisValues are (numCells, numFields, ...)
int numCells = basisValues.dimension(0);
int numFields = basisValues.dimension(1);
Teuchos::Array<int> dimensions;
basisValues.dimensions(dimensions);
int numAffectedValues = 1;
for (int dimIndex=2; dimIndex<dimensions.size(); dimIndex++) {
numAffectedValues *= dimensions[dimIndex];
}
Teuchos::Array<int> index(dimensions.size(),0);
for (int cellIndex=0; cellIndex < numCells; cellIndex++) {
index[0] = cellIndex;
for (int fieldIndex=0; fieldIndex < numFields; fieldIndex++) {
index[1] = fieldIndex;
int enumIndex = basisValues.getEnumeration(index);
for (int valIndex=enumIndex; valIndex < numAffectedValues + enumIndex; valIndex++) {
basisValues[valIndex] *= weights(cellIndex,fieldIndex+offset);
}
}
}
}
void values(FieldContainer<double> &values, BasisCachePtr sliceBasisCache) {
vector<GlobalIndexType> sliceCellIDs = sliceBasisCache->cellIDs();
Teuchos::Array<int> dim;
values.dimensions(dim);
dim[0] = 1; // one cell
Teuchos::Array<int> offset(dim.size());
for (int cellOrdinal = 0; cellOrdinal < sliceCellIDs.size(); cellOrdinal++) {
offset[0] = cellOrdinal;
int enumeration = values.getEnumeration(offset);
FieldContainer<double>valuesForCell(dim,&values[enumeration]);
GlobalIndexType sliceCellID = sliceCellIDs[cellOrdinal];
int numPoints = sliceBasisCache->getPhysicalCubaturePoints().dimension(1);
int spaceDim = sliceBasisCache->getPhysicalCubaturePoints().dimension(2);
FieldContainer<double> spaceTimePhysicalPoints(1,numPoints,spaceDim+1);
for (int ptOrdinal=0; ptOrdinal<numPoints; ptOrdinal++) {
for (int d=0; d<spaceDim; d++) {
spaceTimePhysicalPoints(0,ptOrdinal,d) = sliceBasisCache->getPhysicalCubaturePoints()(cellOrdinal,ptOrdinal,d);
}
spaceTimePhysicalPoints(0,ptOrdinal,spaceDim) = _t;
}
GlobalIndexType cellID = _cellIDMap[sliceCellID];
BasisCachePtr spaceTimeBasisCache = BasisCache::basisCacheForCell(_spaceTimeMesh, cellID);
FieldContainer<double> spaceTimeRefPoints(1,numPoints,spaceDim+1);
CamelliaCellTools::mapToReferenceFrame(spaceTimeRefPoints, spaceTimePhysicalPoints, _spaceTimeMesh, cellID);
spaceTimeRefPoints.resize(numPoints,spaceDim+1);
spaceTimeBasisCache->setRefCellPoints(spaceTimeRefPoints);
_spaceTimeFunction->values(valuesForCell, spaceTimeBasisCache);
}
}
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++;
}
}
}
}
}
}
