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++; } } } } } }