IQI_HdivLF_DivV_Cell::IQI_HdivLF_DivV_Cell( int spatialDim,
const CellType& maxCellType,
const BasisFamily& testBasis,
const QuadratureFamily& quad,
const ParameterList& verbParams):
ElementIntegralLinearFormCell( spatialDim ,
maxCellType ,
testBasis ,
quad ,
verbParams ),
DivV_( testBasis.nReferenceDOFs(maxCellType,maxCellType) , quad.getNumPoints(maxCellType) ),
QP_( quad.getNumPoints( maxCellType ) , spatialDim ),
QW_( quad.getNumPoints( maxCellType ) )
{
// bypass testBasis.refEval and use Intrepid to fill DivV
// warning: only works on tets right now.
Intrepid::Basis_HDIV_TET_I1_FEM<double,Intrepid::FieldContainer<double> > myBasis;
// move quadrature points into a field container
Array<Point> qpSundance;
Array<double> qwSundance;
quad.getPoints( maxCellType , qpSundance , qwSundance );
for (int i=0;i<(int)qpSundance.size();i++) {
for (int j=0;j<3;j++) {
QP_(i,j) = qpSundance[i][j];
}
QW_(i)=qwSundance[i];
}
// now tabulate the divergences
myBasis.getValues( DivV_ , QP_ , Intrepid::OPERATOR_DIV );
}
ExprFieldWrapper::ExprFieldWrapper(const Expr& expr)
: expr_(expr),
df_(),
discreteSpace_(),
//map_(),
indices_(),
Expr_size_(1),
isPointData_(true)
{
int index = 0;
Expr_size_ = expr.size();
// Now it is independent of the size of the size of the Expression
for(index = 0 ; index < Expr_size_ ; index++)
{
const DiscreteFunction* df
= dynamic_cast<const DiscreteFunction*>(expr[index].ptr().get());
const DiscreteFuncElement* dfe
= dynamic_cast<const DiscreteFuncElement*>(expr[index].ptr().get());
if (df != 0)
{
discreteSpace_ = df->discreteSpace();
//map_ = df->map();
indices_.append(tuple(0));
BasisFamily basis = discreteSpace_.basis()[0];
const Lagrange* lagr = dynamic_cast<const Lagrange*>(basis.ptr().get());
if (lagr != 0 && lagr->order()==0) isPointData_ = false;
const EdgeLocalizedBasis* elb = dynamic_cast<const EdgeLocalizedBasis*>(basis.ptr().get());
if (elb!=0) isPointData_ = false;
df_ = df->data();
}
else if (dfe != 0)
{
const DiscreteFunctionData* f = DiscreteFunctionData::getData(dfe);
TEST_FOR_EXCEPTION(f == 0, RuntimeError,
"ExprFieldWrapper ctor argument "
<< expr << " is not a discrete function");
discreteSpace_ = f->discreteSpace();
//map_ = f->map();
indices_.append(tuple(dfe->myIndex()));
BasisFamily basis = discreteSpace_.basis()[indices_[index][0]];
const Lagrange* lagr = dynamic_cast<const Lagrange*>(basis.ptr().get());
if (lagr != 0 && lagr->order()==0) isPointData_ = false;
const EdgeLocalizedBasis* elb = dynamic_cast<const EdgeLocalizedBasis*>(basis.ptr().get());
if (elb!=0) isPointData_ = false;
df_ = f;
}
else
{
TEST_FOR_EXCEPTION(df == 0 && dfe == 0, RuntimeError,
"ExprFieldWrapper ctor argument is not a discrete "
"function");
}
}
}
int main(int argc, char** argv)
{
try
{
GlobalMPISession session(&argc, &argv);
TimeMonitor t(totalTimer());
int pMax = 1;
int dim=2;
CellType cellType = TriangleCell;
Point a = Point(0.0, 0.0);
Point b = Point(1.0, 0.0);
Point c = Point(0.0, 1.0);
CellJacobianBatch JBatch;
JBatch.resize(1, 2, 2);
double* J = JBatch.jVals(0);
J[0] = b[0] - a[0];
J[1] = c[0] - a[0];
J[2] = b[1] - a[1];
J[3] = c[1] - a[1];
bool isInternalBdry=false;
/* ------ evaluate Lagrange and FIAT-Lagrange at the vertices */
Array<Point> verts = tuple(a,b,c);
BasisFamily lagrange = new Lagrange(1);
BasisFamily fiatLagrange = new Lagrange(1);
MultiIndex d0(0,0,0);
MultiIndex dx(1,0,0);
MultiIndex dy(0,1,0);
Array<Array<Array<double> > > result;
Array<int> dummy;
std::cerr << "------ Evaluating bases at vertices ----------" << std::endl
<< std::endl;
std::cerr << "Evaluating phi(vert) with FIAT-Lagrange" << std::endl;
fiatLagrange.ptr()->refEval(cellType, verts, d0, result);
std::cerr << "results = " << result << std::endl << std::endl;
std::cerr << "Evaluating phi(vert) with Lagrange" << std::endl;
lagrange.ptr()->refEval(cellType, verts, d0, result);
std::cerr << "results = " << result << std::endl << std::endl;
std::cerr << std::endl ;
std::cerr << "Evaluating Dx*phi(vert) with FIAT-Lagrange" << std::endl;
fiatLagrange.ptr()->refEval(cellType, verts, dx, result);
std::cerr << "results = " << result << std::endl << std::endl;
std::cerr << "Evaluating Dx*phi(vert) with Lagrange" << std::endl;
lagrange.ptr()->refEval(cellType, verts, dx, result);
std::cerr << "results = " << result << std::endl << std::endl;
std::cerr << std::endl ;
std::cerr << "Evaluating Dy*phi(vert) with FIAT-Lagrange" << std::endl;
fiatLagrange.ptr()->refEval(cellType, verts, dy, result);
std::cerr << "results = " << result << std::endl << std::endl;
std::cerr << "Evaluating Dy*phi(vert) with Lagrange" << std::endl;
lagrange.ptr()->refEval(cellType, verts, dy, result);
std::cerr << "results = " << result << std::endl << std::endl;
/* --------- evaluate integrals over elements ----------- */
RCP<Array<double> > A = rcp(new Array<double>());
QuadratureFamily quad = new GaussianQuadrature(4);
Array<double> quadWeights;
Array<Point> quadPts;
quad.getPoints(cellType, quadPts, quadWeights);
int nQuad = quadPts.size();
Array<double> coeff(nQuad);
for (int i=0; i<nQuad; i++)
{
double s = quadPts[i][0];
double t = quadPts[i][1];
double x = a[0] + J[0]*s + J[1]*t;
double y = a[1] + J[2]*s + J[3]*t;
coeff[i] = x*y;
}
const double* const f = &(coeff[0]);
std::cerr << std::endl << std::endl
<< "---------------- One-forms --------------------"
<< std::endl << std::endl;
for (int p=1; p<=pMax; p++)
{
BasisFamily P = new Lagrange(p);
for (int dp=0; dp<=1; dp++)
{
if (dp > p) continue;
Tabs tab0;
std::cerr << tab0 << "test function deriv order = " << dp << std::endl;
int numTestDir = 1;
if (dp==1) numTestDir = dim;
for (int t=0; t<numTestDir; t++)
{
int alpha = t;
Tabs tab;
QuadratureIntegral ref(dim, cellType, dim, cellType, P, alpha, dp, quad, isInternalBdry);
A->resize(ref.nNodesTest());
ref.transformOneForm(JBatch, JBatch, dummy, f, A);
std::cerr << tab << "test deriv direction =" << t << std::endl;
std::cerr << tab << "transformed local vector: " << std::endl;
std::cerr << tab << "{";
for (int r=0; r<ref.nNodesTest(); r++)
{
if (r!=0) std::cerr << ", ";
std::cerr << (*A)[r];
}
std::cerr << "}" << std::endl << std::endl;
}
}
}
std::cerr << std::endl << std::endl
<< "---------------- Two-forms --------------------"
<< std::endl << std::endl;
for (int p=1; p<=pMax; p++)
{
BasisFamily P = new Lagrange(p);
for (int q=1; q<=pMax; q++)
{
BasisFamily Q = new Lagrange(q);
for (int dp=0; dp<=1; dp++)
{
if (dp > p) continue;
Tabs tab0;
std::cerr << tab0 << "test function deriv order = " << dp << std::endl;
for (int dq=0; dq<=1; dq++)
{
if (dq > q) continue;
Tabs tab1;
std::cerr << tab1
<< "unk function deriv order = " << dq << std::endl;
int numTestDir = 1;
if (dp==1) numTestDir = dim;
for (int t=0; t<numTestDir; t++)
{
int alpha = t;
int numUnkDir = 1;
if (dq==1) numUnkDir = dim;
for (int u=0; u<numUnkDir; u++)
{
Tabs tab;
int beta = u;
QuadratureIntegral ref(dim, cellType, dim, cellType, P, alpha,
dp, Q, beta, dq, quadd, isInternalBdry);
A->resize(ref.nNodesTest()*ref.nNodesUnk());
ref.transformTwoForm(JBatch, JBatch, dummy, f, A);
std::cerr << tab << "test deriv direction =" <<
t << ", unk deriv direction =" << u << std::endl;
std::cerr << tab << "transformed local stiffness matrix" << std::endl;
std::cerr << tab << "{";
for (int r=0; r<ref.nNodesTest(); r++)
{
if (r!=0) std::cerr << ", ";
std::cerr << "{";
for (int c=0; c<ref.nNodesUnk(); c++)
{
if (c!=0) std::cerr << ", ";
std::cerr << chop((*A)[r + ref.nNodesTest()*c]);
}
std::cerr << "}";
}
std::cerr << "}" << std::endl << std::endl;
}
}
}
}
}
}
TimeMonitor::summarize();
}
catch(std::exception& e)
{
std::cerr << e.what() << std::endl;
}
}
void HomogeneousDOFMap::allocate(const Mesh& mesh,
const BasisFamily& basis,
int numFuncs)
{
Tabs tab;
SUNDANCE_MSG1(setupVerb(), tab << "allocating DOF map for nFuncs=" << numFuncs);
Array<int> fid(numFuncs);
for (int f=0; f<numFuncs; f++) fid[f] = f;
funcIDOnCellSets().append(fid);
for (int d=0; d<=dim_; d++)
{
Tabs tab1;
SUNDANCE_MSG2(setupVerb(), tab1 << "allocating d=" << d);
/* record the number of facets for each cell type so we're
* not making a bunch of mesh calls */
numFacets_[d].resize(d);
for (int fd=0; fd<d; fd++) numFacets_[d][fd]=mesh.numFacets(d, 0, fd);
SUNDANCE_MSG3(setupVerb(), tab1 << "num facets for dimension " << d << " is "
<< numFacets_[d]);
/* look up the node pointer for this cell and for all of its
* facets */
basis.ptr()->getLocalDOFs(mesh.cellType(d), localNodePtrs_[d]);
SUNDANCE_MSG3(setupVerb(), tab1 << "node ptrs for dimension " << d << " are "
<< localNodePtrs_[d]);
/* with the node pointers in hand, we can work out the number
* of nodes per cell in this dimension */
if (localNodePtrs_[d][d].size() > 0)
{
nNodesPerCell_[d] = localNodePtrs_[d][d][0].size();
}
else
{
nNodesPerCell_[d] = 0;
}
SUNDANCE_MSG3(setupVerb(), tab1 <<
"num nodes for dimension " << d << " is "
<< nNodesPerCell_[d]);
totalNNodesPerCell_[d] = nNodesPerCell_[d];
for (int dd=0; dd<d; dd++)
{
totalNNodesPerCell_[d] += numFacets_[d][dd]*nNodesPerCell_[dd];
}
/* we know from the mesh the number of cells in this dimension */
if (nNodesPerCell_[d] > 0)
{
dofs_[d].resize(mesh.numCells(d));
}
else
{
dofs_[d].resize(0);
}
if (d > 0 && d < dim_) originalFacetOrientation_[d-1].resize(mesh.numCells(d));
/* If any nodes are associated with the facets, then we know we have
* a continuous basis function */
if (d < dim_ && nNodesPerCell_[d] > 0) basisIsContinuous_ = true;
/* now that we know the number of nodes per cell for this dimension,
* we can allocate space for the DOFs in this dimension */
int numCells = dofs_[d].size();
for (int c=0; c<numCells; c++)
{
dofs_[d][c].resize(funcIDList().size() * nNodesPerCell_[d]);
/* set everything to uninitializedVal() */
for (int i=0; i<dofs_[d][c].size(); i++)
{
dofs_[d][c][i] = uninitializedVal();
}
}
}
SUNDANCE_MSG1(setupVerb(), tab << "done allocating DOF map");
}
void checkbasis( BasisFamily &b1 , BasisFamily &b2 )
{
int maxDim=3;
double tol = 1.0e-13;
int maxDiffOrder = 0;
int numErrors = 0;
QuadratureFamily quad = new GaussianQuadrature(4);
for (int spatialDim=1; spatialDim<=maxDim; spatialDim++) {
std::cerr << "\t" << "spatial dimension =" << spatialDim << std::endl;
for (int cellDim=0; cellDim<=spatialDim; cellDim++) {
std::cerr << "\t\t" << "cell dimension =" << cellDim << std::endl;
CellType cellType;
if (cellDim==0) cellType=PointCell;
if (cellDim==1) cellType=LineCell;
if (cellDim==2) cellType=TriangleCell;
if (cellDim==3) cellType=TetCell;
Array<Point> qPts;
Array<double> qWts;
quad.getPoints(cellType, qPts, qWts);
for (int d=0; d<=maxDiffOrder; d++) {
if (cellDim==0 && d>0) continue;
cerr << "\t\t\t" << "differentiation order = " << d << std::endl;
for (int dir=0; dir<iPow(cellDim, d); dir++) {
std::cerr << "\t\t\t\t" << "direction = " << dir << std::endl;
MultiIndex mi;
mi[dir]=d;
Array<Array<double> > values1;
Array<Array<double> > values2;
std::cerr << "\t\t\t\t" << "computing basis1...";
b1.ptr()->refEval(spatialDim, cellType, qPts, mi, values1);
std::cerr << "done" << std::endl << "\t\t\t\t" << "computing basis2...";
b2.ptr()->refEval(spatialDim, cellType, qPts, mi, values2);
std::cerr << "done" << std::endl;
int nNodes1 = b1.ptr()->nNodes(spatialDim, cellType);
int nNodes2 = b2.ptr()->nNodes(spatialDim, cellType);
std::cerr << "\t\t\t\t" << "num nodes: basis1=" << nNodes1
<< " basis2=" << nNodes2 << std::endl;
if (nNodes1 != nNodes2) {
std::cerr << "******** ERROR: node counts should be equal" << std::endl;
numErrors++;
continue;
}
if (values1.size() != values2.size()) {
std::cerr << "******** ERROR: value array outer sizes should be equal" << std::endl;
numErrors++;
continue;
}
if (values1.size() != qPts.size()) {
std::cerr << "******** ERROR: value array outer size should be equal to number of quad points" << std::endl;
numErrors++;
continue;
}
for (int q=0; q<qPts.length(); q++) {
if (values1[q].length() != nNodes1) {
std::cerr << "******** ERROR: value array inner size should be equal to number of nodes" << std::endl;
numErrors++;
continue;
}
std::cerr << "\t\t\t\t\t" << "quad point q=" << q << " pt=" << qPts[q]
<< std::endl;
for (int n=0; n<nNodes1; n++) {
std::cerr << "\t\t\t\t\t\t" << "node n=" << n << " phi1="
<< values1[q][n]
<< " phi2=" << values2[q][n]
<< " |phi1-phi2|=" << fabs(values1[q][n]-values2[q][n])
<< std::endl;
if (fabs(values1[q][n]-values2[q][n]) > tol) {
cout << "ERROR" << std::endl; numErrors++;
}
}
}
}
}
}
}
std::cerr << std::endl << std::endl << "Summary: detected " << numErrors << " errors " << std::endl;
}
void CurveEvalMediator
::evalDiscreteFuncElement(const DiscreteFuncElement* expr,
const Array<MultiIndex>& multiIndices,
Array<RCP<EvalVector> >& vec) const
{
int verbo = dfVerb();
Tabs tab1;
SUNDANCE_MSG2(verbo , tab1
<< "CurveEvalMediator evaluating Discrete Function expr " << expr->toString());
const DiscreteFunctionData* f = DiscreteFunctionData::getData(expr);
TEUCHOS_TEST_FOR_EXCEPTION(f==0, std::logic_error,
"QuadratureEvalMediator::evalDiscreteFuncElement() called "
"with expr that is not a discrete function");
SUNDANCE_MSG2(verbo , tab1 << "After casting DiscreteFunctionData" << expr->toString());
RCP<Array<Array<double> > > localValues;
Array<int> cellLIDs_tmp(1);
Array<Point> phyPoints;
Array<Point> refPoints;
Array<Point> refDevs;
Array<Point> refNormal;
int nCells = cellLID()->size();
RCP<const MapStructure> mapStruct;
int myIndex = expr->myIndex();
int nQuad = numQuadPtsForMaxCell_;
Array<int> k(multiIndices.size(),0);
Teuchos::BLAS<int,double> blas;
SUNDANCE_MSG2(verbo , tab1 << "After declaring BLAS: " << expr->toString());
// resize correctly the result vector
for (int i=0; i<multiIndices.size(); i++)
{
vec[i]->resize(nCells*nQuad);
}
// loop over each cell
for (int c=0; c<nCells; c++)
{
int maxCellLID = (*cellLID())[c];
localValues = rcp(new Array<Array<double> >());
SUNDANCE_MSG2(verbo , tab1 << "Cell:" << c << " of " << nCells << " , maxCellLID:" << maxCellLID );
cellLIDs_tmp[0] = (*cellLID())[c];
SUNDANCE_MSG2(verbo , tab1 << " Before calling f->getLocalValues:" << cellLIDs_tmp.size() <<
" f==0 : " << (f==0) << " tmp:" << f->mesh().spatialDim());
// - get local values from the DiscreteFunctionElementData
mapStruct = f->getLocalValues(maxCellDim(), cellLIDs_tmp , *localValues);
SUNDANCE_MSG2(verbo , tab1 << " After getting mapStruct:" << maxCellLID );
SUNDANCE_MSG2(verbo , tab1 << " mapStruct->numBasisChunks():" << mapStruct->numBasisChunks() );
int chunk = mapStruct->chunkForFuncID(myIndex);
int funcIndex = mapStruct->indexForFuncID(myIndex);
int nFuncs = mapStruct->numFuncs(chunk);
SUNDANCE_MSG2(verbo , tab1 << " chunk:" << chunk );
SUNDANCE_MSG2(verbo , tab1 << " funcIndex:" << funcIndex );
SUNDANCE_MSG2(verbo , tab1 << " nFuncs:" << nFuncs );
// the chunk of the function
BasisFamily basis = rcp_dynamic_cast<BasisFamilyBase>(mapStruct->basis(chunk));
int nNodesTotal = basis.nReferenceDOFsWithFacets(maxCellType(), maxCellType());
// - get intersection (reference)points from the mesh (if not existent than compute them)
if ( mesh().hasCurvePoints( maxCellLID , paramcurve_.myID() ))
{
mesh().getCurvePoints( maxCellLID , paramcurve_.myID() , refPoints , refDevs , refNormal );
}
else // we have to calculate now the points
{
// calculate the intersection points
CurveIntegralCalc::getCurveQuadPoints( maxCellType_ , maxCellLID , mesh() , paramcurve_ , quad_ ,
refPoints, refDevs , refNormal);
// store the intersection point in the mesh
mesh().setCurvePoints( maxCellLID , paramcurve_.myID() , refPoints, refDevs , refNormal );
}
// loop over each multi-index
SUNDANCE_MSG2(verbo , tab1 << " multiIndices.size()" << multiIndices.size() );
for (int i=0; i<multiIndices.size(); i++)
{
int nDerivResults = 1;
if ( multiIndices[i].order() == 1 ) nDerivResults = maxCellDim();
int pDir = 0;
int derivNum = 1;
MultiIndex mi;
SUNDANCE_MSG2(verbo , tab1 << " before asking anything i = " << i);
SUNDANCE_MSG2(verbo , tab1 << " multiindex order : " << multiIndices[i].order());
SUNDANCE_MSG2(verbo , tab1 << " multiindex : " << multiIndices[i] );
if (multiIndices[i].order() > 0){
pDir = multiIndices[i].firstOrderDirection();
mi[pDir] = 1;
derivNum = mesh().spatialDim();
}
Array<Array<double> > result(nQuad*derivNum);
Array<Array<Array<double> > > tmp;
int offs = nNodesTotal;
// resize the result vector
for (int deriv = 0 ; deriv < derivNum ; deriv++)
{
// test weather we have to compute derivative
if (multiIndices[i].order() > 0){
// in case of derivatives we set one dimension
MultiIndex mi_tmp;
mi_tmp[deriv] = 1;
SpatialDerivSpecifier deriv(mi_tmp);
SUNDANCE_MSG2(verbo , tab1 << "computing derivatives : " << deriv << " on reference cell ");
basis.refEval( maxCellType_ , refPoints , deriv, tmp , verbo );
} else {
SpatialDerivSpecifier deriv(mi);
// --- end eval basis functions
SUNDANCE_MSG2(verbo , tab1 << "computing values reference cell ");
basis.refEval( maxCellType_ , refPoints , deriv, tmp , verbo );
}
SUNDANCE_MSG2(verbo , tab1 << "resize result vector , offs:" << offs);
for (int q=0; q<nQuad; q++){
result[nQuad*deriv + q].resize(offs);
}
// copy the result in an other format
SUNDANCE_MSG2(verbo , tab1 << "copy results ");
int offs1 = 0;
for (int q=0; q<nQuad; q++)
{
offs1 = 0;
for (int d=0; d<basis.dim(); d++)
{
int nNodes = tmp[d][q].size();
for (int n=0; n<nNodes; n++ , offs1++ )
{
result[nQuad*deriv + q][offs1] = tmp[d][q][n];
}
}
}
}// loop over all dimensional derivative
// multiply the local results with the coefficients, (matrix vector OP)
SUNDANCE_MSG2(verbo , tab1 << "summing up values , funcIndex:" << funcIndex << " offs:" << offs);
for (int deriv = 0 ; deriv < derivNum ; deriv++)
{
for (int q=0; q<nQuad; q++)
{
double sum = 0.0;
// sum over nodes
for (int n = 0 ; n < offs ; n++){
sum = sum + result[nQuad*deriv + q][n] * (*localValues)[chunk][funcIndex*offs + n];
}
// sum up the result in the 0th element
result[nQuad*deriv + q][0] = sum;
}
}
// multiply the result if necesary with the inverse of the Jacobian
const CellJacobianBatch& J = JTrans();
if (mi.order()==1)
{
Tabs tab1;
Tabs tab2;
SUNDANCE_MSG2(verbo, tab2 << "Jacobian batch nCells=" << J.numCells());
SUNDANCE_MSG2(verbo, tab2 << "Jacobian batch cell dim=" << J.cellDim());
SUNDANCE_MSG2(verbo, tab2 << "Jacobian batch spatial dim=" << J.spatialDim());
// we just multiply the derivative direction component
Array<double> invJ;
J.getInvJ(c, invJ);
for (int q=0; q<nQuad; q++)
{
double sum = 0.0;
for (int deriv = 0 ; deriv < derivNum ; deriv++)
{
// multiply one row from the J^{-T} matrix with the gradient vector
sum = sum + result[nQuad*deriv + q][0] * invJ[derivNum*pDir + deriv];
}
// the resulting derivative on the physical cell in the "pDir" direction
result[q][0] = sum;
}
}
// --- just copy the result to the "vec" back, the result should be in the "result[q][0]" place----
//SUNDANCE_MSG2(verbo , tab1 << "copy results back ");
double* vecPtr = vec[i]->start();
for (int q=0; q<nQuad; q++, k[i]++)
{
vecPtr[k[i]] = result[q][0];
}
SUNDANCE_MSG2(verbo , tab1 << " END copy results back ");
} // --- end loop multiindex
SUNDANCE_MSG2(verbo , tab1 << " END loop over multiindex ");
}// --- end loop over cells
SUNDANCE_MSG2(verbo , tab1 << " END loop over cells ");
}
MaximalQuadratureIntegral::MaximalQuadratureIntegral(
const CellType& cellType,
const BasisFamily& testBasis,
int alpha,
int testDerivOrder,
const BasisFamily& unkBasis,
int beta,
int unkDerivOrder,
const QuadratureFamily& quad,
const ParametrizedCurve& globalCurve,
const Mesh& mesh,
int verb)
: ElementIntegral(dimension(cellType), cellType, dimension(cellType),
cellType, testBasis,
alpha, testDerivOrder, unkBasis, beta, unkDerivOrder, true,
globalCurve, mesh,
verb),
quad_(quad),
quadPts_(),
quadWeights_(),
W_(),
useSumFirstMethod_(true)
{
Tabs tab0(0);
SUNDANCE_MSG1(setupVerb(), tab0 << "MaximalQuadratureIntegral ctor for 2-form");
if (setupVerb()) describe(Out::os());
assertBilinearForm();
// store the quadrature points and weights
quad.getPoints(cellType, quadPts_, quadWeights_);
int nQuad = quadPts_.size();
W_.resize(nQuad * nRefDerivTest() * nNodesTest()
* nRefDerivUnk() * nNodesUnk());
/* compute the basis functions */
Array<Array<Array<Array<double> > > > testBasisVals(nRefDerivTest());
Array<Array<Array<Array<double> > > > unkBasisVals(nRefDerivUnk());
for (int r=0; r<nRefDerivTest(); r++)
{
testBasisVals[r].resize(testBasis.dim());
MultiIndex mi;
if (testDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
testBasis.refEval(evalCellType(), quadPts_, deriv,
testBasisVals[r], setupVerb());
}
for (int r=0; r<nRefDerivUnk(); r++)
{
unkBasisVals[r].resize(unkBasis.dim());
MultiIndex mi;
if (unkDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
unkBasis.refEval(evalCellType(),
quadPts_, deriv, unkBasisVals[r], setupVerb());
}
int vecComp = 0;
/* form the products of basis functions at each quad pt */
W_ACI_F2_.resize(nQuad);
for (int q=0; q<nQuad; q++)
{
W_ACI_F2_[q].resize(nRefDerivTest());
for (int t=0; t<nRefDerivTest(); t++)
{
W_ACI_F2_[q][t].resize(nNodesTest());
for (int nt=0; nt<nNodesTest(); nt++)
{
W_ACI_F2_[q][t][nt].resize(nRefDerivUnk());
for (int u=0; u<nRefDerivUnk(); u++)
{
W_ACI_F2_[q][t][nt][u].resize(nNodesUnk());
for (int nu=0; nu<nNodesUnk(); nu++)
{
wValue(q, t, nt, u, nu)
= chop(quadWeights_[q] * testBasisVals[t][vecComp][q][nt]
* unkBasisVals[u][vecComp][q][nu]);
W_ACI_F2_[q][t][nt][u][nu] =
chop(testBasisVals[t][vecComp][q][nt] * unkBasisVals[u][vecComp][q][nu]);
}
}
}
}
}
addFlops(3*nQuad*nRefDerivTest()*nNodesTest()*nRefDerivUnk()*nNodesUnk()
+ W_.size());
for (int i=0; i<W_.size(); i++) W_[i] = chop(W_[i]);
}
MaximalQuadratureIntegral::MaximalQuadratureIntegral(
const CellType& cellType,
const BasisFamily& testBasis,
int alpha,
int testDerivOrder,
const QuadratureFamily& quad,
const ParametrizedCurve& globalCurve,
const Mesh& mesh,
int verb)
: ElementIntegral(dimension(cellType), cellType, dimension(cellType),
cellType, testBasis,
alpha, testDerivOrder, true, globalCurve, mesh, verb),
quad_(quad),
quadPts_(),
quadWeights_(),
W_(),
useSumFirstMethod_(true)
{
Tabs tab0(0);
SUNDANCE_MSG1(setupVerb(), tab0 << "MaximalQuadratureIntegral ctor for 1-form");
if (setupVerb()) describe(Out::os());
assertLinearForm();
SUNDANCE_MSG1(setupVerb(), tab0 << "quadrature family=" << quad);
quad.getPoints(cellType, quadPts_, quadWeights_);
int nQuad = quadPts_.size();
W_.resize(nQuad * nRefDerivTest() * nNodesTest());
SUNDANCE_MSG1(setupVerb(), tab0 << "num nodes for test function " << nNodesTest());
Array<Array<Array<Array<double> > > > testBasisVals(nRefDerivTest());
for (int r=0; r<nRefDerivTest(); r++)
{
Tabs tab3;
SUNDANCE_MSG1(setupVerb(), tab3
<< "evaluating basis functions for ref deriv direction " << r);
MultiIndex mi;
testBasisVals[r].resize(testBasis.dim());
if (testDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
testBasis.refEval(evalCellType(), quadPts_, deriv,
testBasisVals[r], setupVerb());
}
int vecComp = 0;
W_ACI_F1_.resize(nQuad);
for (int q=0; q<nQuad; q++)
{
W_ACI_F1_[q].resize(nRefDerivTest());
for (int t=0; t<nRefDerivTest(); t++)
{
W_ACI_F1_[q][t].resize(nNodesTest());
for (int nt=0; nt<nNodesTest(); nt++)
{
wValue(q, t, nt)
= chop(quadWeights_[q] * testBasisVals[t][vecComp][q][nt]) ;
W_ACI_F1_[q][t][nt] = chop(testBasisVals[t][vecComp][q][nt]);
}
}
}
addFlops(2*nQuad*nRefDerivTest()*nNodesTest());
}
ElementIntegral::ElementIntegral(int spatialDim,
const CellType& maxCellType,
int dim,
const CellType& cellType,
const BasisFamily& testBasis,
int alpha,
int testDerivOrder,
bool isInternalBdry,
const ParametrizedCurve& globalCurve,
const Mesh& mesh,
int verb)
: setupVerb_(verb),
integrationVerb_(0),
transformVerb_(0),
spatialDim_(spatialDim),
dim_(dim),
isInternalBdry_(isInternalBdry),
nFacetCases_(1),
testDerivOrder_(testDerivOrder),
nRefDerivTest_(ipow(spatialDim, testDerivOrder)),
nNodesTest_(testBasis.nReferenceDOFsWithFacets(maxCellType, cellType)),
unkDerivOrder_(-1),
nRefDerivUnk_(-1),
nNodesUnk_(-1),
nNodes_(nNodesTest_),
order_(1),
alpha_(alpha),
beta_(-1),
cellType_(cellType),
maxCellType_(maxCellType),
evalCellType_(cellType),
testBasis_(testBasis),
unkBasis_(),
globalCurve_(globalCurve),
mesh_(mesh)
{
Tabs tab0(0);
SUNDANCE_MSG2(setupVerb(), tab0 << "constructing 1-form ElementIntegral");
/* if we're integrating a derivative along a facet, we
* may need to refer back to the maximal cell. */
bool okToRestrictTestToBdry = basisRestrictableToBoundary(testBasis);
Tabs tab1;
SUNDANCE_MSG2(setupVerb(), tab1 << "dim=" << dim << " spatialDim=" << spatialDim);
if (dim != spatialDim)
{
if (isInternalBdry)
{
TEST_FOR_EXCEPT(!okToRestrictTestToBdry);
}
if (alwaysUseCofacets() || testDerivOrder>0)
{
Tabs tab2;
evalCellType_ = maxCellType_;
nFacetCases_ = numFacets(maxCellType, dim);
nNodesTest_ = testBasis.nReferenceDOFsWithFacets(maxCellType, maxCellType);
SUNDANCE_MSG2(setupVerb(), tab2 << "nNodesTest=" << nNodesTest_);
nNodes_ = nNodesTest_;
TEST_FOR_EXCEPT(nNodes_ == 0);
}
else
{
TEST_FOR_EXCEPT(!okToRestrictTestToBdry);
}
}
SUNDANCE_MSG2(setupVerb(), tab1 << "nNodes=" << nNodes_);
}
RefIntegral::RefIntegral(int spatialDim,
const CellType& maxCellType,
int dim,
const CellType& cellType,
const BasisFamily& testBasis,
int alpha,
int testDerivOrder,
const BasisFamily& unkBasis,
int beta,
int unkDerivOrder,
const QuadratureFamily& quad_in,
bool isInternalBdry,
const ParametrizedCurve& globalCurve,
const Mesh& mesh,
int verb)
: ElementIntegral(spatialDim, maxCellType, dim, cellType,
testBasis, alpha, testDerivOrder,
unkBasis, beta, unkDerivOrder, isInternalBdry, globalCurve , mesh ,verb), W_()
{
Tabs tab0(0);
SUNDANCE_MSG1(setupVerb(),
tab0 << "************* creating reference 2-form integrals ********");
if (setupVerb()) describe(Out::os());
assertBilinearForm();
W_.resize(nFacetCases());
W_ACI_F2_.resize(nFacetCases());
QuadratureType qType = new GaussianQuadratureType();
int reqOrder = qType.findValidOrder(cellType,
std::max(1, unkBasis.order() + testBasis.order()));
SUNDANCE_MSG2(setupVerb(),
tab0 << "using quadrature order=" << reqOrder);
QuadratureFamily quad = qType.createQuadFamily(reqOrder);
/* If we have a valid curve (in case of Adaptive Cell Integration)
* then we have to choose the quadrature which the user specified*/
if (globalCurve.isCurveValid()){
quad = quad_in;
Tabs tab1;
SUNDANCE_MSG1(setupVerb(),tab1 << "ACI change quadrature to Quadrature of order: "<<quad.order());
}
quad_ = quad;
SUNDANCE_MSG2(setupVerb(),
tab0 << "processing evaluation cases");
for (int fc=0; fc<nFacetCases(); fc++)
{
Tabs tab1;
SUNDANCE_MSG1(setupVerb(), tab1 << "------ evaluation case " << fc << " of "
<< nFacetCases() << "-------");
W_[fc].resize(nRefDerivTest() * nNodesTest() * nRefDerivUnk() * nNodesUnk());
for (int i=0; i<W_[fc].size(); i++) W_[fc][i]=0.0;
Array<Array<Array<Array<double> > > > testBasisVals(nRefDerivTest());
Array<Array<Array<Array<double> > > > unkBasisVals(nRefDerivUnk());
getQuad(quad, fc, quadPts_, quadWeights_);
int nQuad = quadPts_.size();
for (int r=0; r<nRefDerivTest(); r++)
{
Tabs tab2;
SUNDANCE_MSG2(setupVerb(), tab2
<< "evaluating test function basis derivative "
<< r << " of " << nRefDerivTest());
testBasisVals[r].resize(testBasis.dim());
MultiIndex mi;
if (testDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
testBasis.refEval(evalCellType(), quadPts_, deriv,
testBasisVals[r], setupVerb());
}
for (int r=0; r<nRefDerivUnk(); r++)
{
Tabs tab2;
SUNDANCE_MSG2(setupVerb(), tab2
<< "evaluating unknown function basis derivative "
<< r << " of " << nRefDerivUnk());
unkBasisVals[r].resize(unkBasis.dim());
MultiIndex mi;
if (unkDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
unkBasis.refEval(evalCellType(),
quadPts_, deriv, unkBasisVals[r], setupVerb());
}
SUNDANCE_MSG2(setupVerb(), tab1 << "doing quadrature...");
int vecComp = 0;
W_ACI_F2_[fc].resize(nQuad);
for (int q=0; q<nQuad; q++)
{
W_ACI_F2_[fc][q].resize(nRefDerivTest());
for (int t=0; t<nRefDerivTest(); t++)
{
W_ACI_F2_[fc][q][t].resize(nNodesTest());
for (int nt=0; nt<nNodesTest(); nt++)
{
W_ACI_F2_[fc][q][t][nt].resize(nRefDerivUnk());
for (int u=0; u<nRefDerivUnk(); u++)
{
W_ACI_F2_[fc][q][t][nt][u].resize(nNodesUnk());
for (int nu=0; nu<nNodesUnk(); nu++)
{
value(fc, t, nt, u, nu)
+= chop(quadWeights_[q] * testBasisVals[t][vecComp][q][nt]
* unkBasisVals[u][vecComp][q][nu]);
W_ACI_F2_[fc][q][t][nt][u][nu] = chop( testBasisVals[t][vecComp][q][nt]
* unkBasisVals[u][vecComp][q][nu] );
}
}
}
}
}
SUNDANCE_MSG2(setupVerb(), tab1 << "...done");
addFlops(4*nQuad*nRefDerivTest()*nNodesTest()*nRefDerivUnk()*nNodesUnk()
+ W_[fc].size());
for (int i=0; i<W_[fc].size(); i++) W_[fc][i] = chop(W_[fc][i]);
}
SUNDANCE_MSG1(setupVerb(), tab0
<< "----------------------------------------");
SUNDANCE_MSG4(setupVerb(), tab0
<< "reference bilinear form integral results");
if (setupVerb() >= 4)
{
for (int fc=0; fc<nFacetCases(); fc++)
{
Tabs tab1;
SUNDANCE_MSG4(setupVerb(), tab1 << "evaluation case " << fc << " of "
<< nFacetCases());
for (int rt=0; rt<nRefDerivTest(); rt++)
{
for (int ru=0; ru<nRefDerivUnk(); ru++)
{
Tabs tab2;
MultiIndex miTest;
if (testDerivOrder==1) miTest[rt] = 1;
MultiIndex miUnk;
if (unkDerivOrder==1) miUnk[ru] = 1;
SUNDANCE_MSG1(setupVerb(), tab2 << "test multiindex=" << miTest
<< " unk multiindex=" << miUnk);
ios_base::fmtflags oldFlags = Out::os().flags();
Out::os().setf(ios_base::right);
Out::os().setf(ios_base::showpoint);
for (int nt=0; nt<nNodesTest(); nt++)
{
Tabs tab3;
Out::os() << tab3 << setw(10) << nt;
for (int nu=0; nu<nNodesUnk(); nu++)
{
Out::os() << setw(12) << std::setprecision(5)
<< value(fc, rt, nt, ru, nu) ;
}
Out::os() << std::endl;
}
Out::os().flags(oldFlags);
}
}
}
}
SUNDANCE_MSG1(setupVerb(), tab0 << "done reference bilinear form ctor");
}
RefIntegral::RefIntegral(int spatialDim,
const CellType& maxCellType,
int dim,
const CellType& cellType,
const BasisFamily& testBasis,
int alpha,
int testDerivOrder,
const QuadratureFamily& quad_in,
bool isInternalBdry,
const ParametrizedCurve& globalCurve,
const Mesh& mesh,
int verb)
: ElementIntegral(spatialDim, maxCellType, dim, cellType,
testBasis, alpha, testDerivOrder, isInternalBdry, globalCurve , mesh , verb), W_()
{
Tabs tab0(0);
SUNDANCE_MSG1(setupVerb(),
tab0 << "************* creating reference 1-form integrals ********");
if (setupVerb()) describe(Out::os());
assertLinearForm();
W_.resize(nFacetCases());
W_ACI_F1_.resize(nFacetCases());
/* Determine the quadrature order needed for exact integrations */
QuadratureType qType = new GaussianQuadratureType();
int reqOrder = qType.findValidOrder(cellType,
std::max(1, testBasis.order()));
SUNDANCE_MSG2(setupVerb(),
tab0 << "using quadrature order=" << reqOrder);
/* Create a quadrature family of the required order */
QuadratureFamily quad = qType.createQuadFamily(reqOrder);
/* If we have a valid curve (in case of Adaptive Cell Integration)
* then we have to choose the quadrature which the user specified*/
if (globalCurve.isCurveValid()){
quad = quad_in;
Tabs tab1;
SUNDANCE_MSG1(setupVerb(),tab1 << "ACI change quadrature to Quadrature of order: "<<quad.order());
}
quad_ = quad;
/* We now loop over the different evaluation cases, integrating the
* basis functions for each. Because this is a reference integral,
* we can actually do the untransformed integrals here. */
for (int fc=0; fc<nFacetCases(); fc++)
{
Tabs tab1;
SUNDANCE_MSG2(setupVerb(),
tab1 << "evaluation case=" << fc << " of " << nFacetCases());
/* initialize size of untransformed integral results array */
W_[fc].resize(nRefDerivTest() * nNodesTest());
/* initialize values of integrals to zero */
for (int i=0; i<W_[fc].size(); i++) { W_[fc][i]=0.0; }
Array<Array<Array<Array<double> > > > testBasisVals(nRefDerivTest());
/* get quadrature points */
getQuad(quad, fc, quadPts_, quadWeights_);
int nQuad = quadPts_.size();
/* compute the basis functions */
for (int r=0; r<nRefDerivTest(); r++)
{
Tabs tab2;
SUNDANCE_MSG2(setupVerb(), tab2 << "evaluating basis derivative "
<< r << " of " << nRefDerivTest());
testBasisVals[r].resize(testBasis.dim());
MultiIndex mi;
if (testDerivOrder==1) mi[r] = 1;
SpatialDerivSpecifier deriv(mi);
testBasis.refEval(evalCellType(), quadPts_, deriv,
testBasisVals[r], setupVerb());
}
/* do the quadrature */
SUNDANCE_MSG2(setupVerb(), tab1 << "doing quadrature");
int vecComp = 0;
W_ACI_F1_[fc].resize(nQuad);
for (int q=0; q<nQuad; q++)
{
W_ACI_F1_[fc][q].resize(nRefDerivTest());
for (int t=0; t<nRefDerivTest(); t++)
{
W_ACI_F1_[fc][q][t].resize(nNodesTest());
for (int nt=0; nt<nNodesTest(); nt++)
{
value(fc, t, nt)
+= chop(quadWeights_[q] * testBasisVals[t][vecComp][q][nt]) ;
W_ACI_F1_[fc][q][t][nt] = chop(testBasisVals[t][vecComp][q][nt]);
}
}
}
for (int i=0; i<W_[fc].size(); i++) W_[fc][i] = chop(W_[fc][i]);
addFlops(3*nQuad*nRefDerivTest()*nNodesTest() + W_[fc].size());
}
/* print the result */
SUNDANCE_MSG4(setupVerb(), tab0 << "--------------------------------------");
SUNDANCE_MSG4(setupVerb(), tab0 << "reference linear form integral results");
if (setupVerb() >= 4)
{
for (int fc=0; fc<nFacetCases(); fc++)
{
Tabs tab1;
SUNDANCE_MSG4(setupVerb(), tab1 << "------ evaluation case " << fc << " of "
<< nFacetCases() << "-------");
for (int r=0; r<nRefDerivTest(); r++)
{
Tabs tab2;
MultiIndex mi;
if (testDerivOrder==1) mi[r] = 1;
SUNDANCE_MSG1(setupVerb(), tab2 << "multiindex=" << mi);
ios_base::fmtflags oldFlags = Out::os().flags();
Out::os().setf(ios_base::right);
Out::os().setf(ios_base::showpoint);
for (int nt=0; nt<nNodesTest(); nt++)
{
Tabs tab3;
Out::os() << tab3 << setw(10) << nt
<< setw(12) << std::setprecision(5) << value(fc, r, nt)
<< std::endl;
}
Out::os().flags(oldFlags);
}
}
}
SUNDANCE_MSG1(setupVerb(), tab0 << "done reference linear form ctor");
}
SubmaximalNodalDOFMap
::SubmaximalNodalDOFMap(const Mesh& mesh,
const CellFilter& cf,
int nFuncs,
int setupVerb)
: DOFMapBase(mesh, setupVerb),
dim_(0),
nTotalFuncs_(nFuncs),
domain_(cf),
domains_(tuple(cf)),
nodeLIDs_(),
nodeDOFs_(),
lidToPtrMap_(),
mapStructure_()
{
Tabs tab0(0);
SUNDANCE_MSG1(setupVerb, tab0 << "in SubmaximalNodalDOFMap ctor");
Tabs tab1;
SUNDANCE_MSG2(setupVerb, tab1 << "domain " << domain_);
SUNDANCE_MSG2(setupVerb, tab1 << "N funcs " << nFuncs);
const MPIComm& comm = mesh.comm();
int rank = comm.getRank();
int nProc = comm.getNProc();
dim_ = cf.dimension(mesh);
TEUCHOS_TEST_FOR_EXCEPT(dim_ != 0);
CellSet nodes = cf.getCells(mesh);
int nc = nodes.numCells();
nodeLIDs_.reserve(nc);
nodeDOFs_.reserve(nc);
Array<Array<int> > remoteNodes(nProc);
int nextDOF = 0;
int k=0;
for (CellIterator c=nodes.begin(); c!=nodes.end(); c++, k++)
{
int nodeLID = *c;
lidToPtrMap_.put(nodeLID, k);
nodeLIDs_.append(nodeLID);
int remoteOwner = rank;
if (isRemote(0, nodeLID, remoteOwner))
{
int GID = mesh.mapLIDToGID(0, nodeLID);
remoteNodes[remoteOwner].append(GID);
for (int f=0; f<nFuncs; f++) nodeDOFs_.append(-1);
}
else
{
for (int f=0; f<nFuncs; f++) nodeDOFs_.append(nextDOF++);
}
}
/* Compute offsets for each processor */
int localCount = nextDOF;
computeOffsets(localCount);
/* Resolve remote DOF numbers */
shareRemoteDOFs(remoteNodes);
BasisFamily basis = new Lagrange(1);
mapStructure_ = rcp(new MapStructure(nTotalFuncs_, basis.ptr()));
}
