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())); }