bool ASMs3Dmx::evalSolution (Matrix& sField, const IntegrandBase& integrand, const RealArray* gpar, bool regular) const { sField.resize(0,0); if (m_basis.empty()) return false; // Evaluate the basis functions and their derivatives at all points std::vector<std::vector<Go::BasisDerivs>> splinex(m_basis.size()); if (regular) { for (size_t b = 0; b < m_basis.size(); ++b) m_basis[b]->computeBasisGrid(gpar[0],gpar[1],gpar[2],splinex[b]); } else if (gpar[0].size() == gpar[1].size() && gpar[0].size() == gpar[2].size()) { for (size_t b = 0; b < m_basis.size(); ++b) { splinex[b].resize(gpar[0].size()); for (size_t i = 0; i < splinex[b].size(); i++) m_basis[b]->computeBasis(gpar[0][i],gpar[1][i],gpar[2][i],splinex[b][i]); } } std::vector<size_t> elem_sizes; for (auto& it : m_basis) elem_sizes.push_back(it->order(0)*it->order(1)*it->order(2)); // Fetch nodal (control point) coordinates Matrix Xnod, Xtmp; this->getNodalCoordinates(Xnod); MxFiniteElement fe(elem_sizes,firstIp); Vector solPt; std::vector<Matrix> dNxdu(m_basis.size()); Matrix Jac; Vec3 X; // Evaluate the secondary solution field at each point size_t nPoints = splinex[0].size(); for (size_t i = 0; i < nPoints; i++, fe.iGP++) { // Fetch indices of the non-zero basis functions at this point std::vector<IntVec> ip(m_basis.size()); IntVec ipa; size_t ofs = 0; for (size_t b = 0; b < m_basis.size(); ++b) { scatterInd(m_basis[b]->numCoefs(0),m_basis[b]->numCoefs(1),m_basis[b]->numCoefs(2), m_basis[b]->order(0),m_basis[b]->order(1),m_basis[b]->order(2), splinex[b][i].left_idx,ip[b]); // Fetch associated control point coordinates if (b == (size_t)geoBasis-1) utl::gather(ip[geoBasis-1], 3, Xnod, Xtmp); for (auto& it : ip[b]) it += ofs; ipa.insert(ipa.end(), ip[b].begin(), ip[b].end()); ofs += nb[b]; } fe.u = splinex[0][i].param[0]; fe.v = splinex[0][i].param[1]; fe.w = splinex[0][i].param[2]; // Fetch basis function derivatives at current integration point for (size_t b = 0; b < m_basis.size(); ++b) SplineUtils::extractBasis(splinex[b][i],fe.basis(b+1),dNxdu[b]); // Compute Jacobian inverse of the coordinate mapping and // basis function derivatives w.r.t. Cartesian coordinates fe.detJxW = utl::Jacobian(Jac,fe.grad(geoBasis),Xtmp,dNxdu[geoBasis-1]); for (size_t b = 1; b <= m_basis.size(); b++) if (b != (size_t)geoBasis) { if (fe.detJxW == 0.0) fe.grad(b).clear(); else fe.grad(b).multiply(dNxdu[b-1],Jac); } // Cartesian coordinates of current integration point X = Xtmp * fe.basis(geoBasis); // Now evaluate the solution field if (!integrand.evalSol(solPt,fe,X,ipa,elem_sizes,nb)) return false; else if (sField.empty()) sField.resize(solPt.size(),nPoints,true); sField.fillColumn(1+i,solPt); } return true; }
bool ASMs3Dmx::integrate (Integrand& integrand, int lIndex, GlobalIntegral& glInt, const TimeDomain& time) { if (!svol) return true; // silently ignore empty patches if (m_basis.empty()) return false; PROFILE2("ASMs3Dmx::integrate(B)"); bool useElmVtx = integrand.getIntegrandType() & Integrand::ELEMENT_CORNERS; std::map<char,ThreadGroups>::const_iterator tit; if ((tit = threadGroupsFace.find(lIndex)) == threadGroupsFace.end()) { std::cerr <<" *** ASMs3D::integrate: No thread groups for face "<< lIndex << std::endl; return false; } const ThreadGroups& threadGrp = tit->second; // Get Gaussian quadrature points and weights const double* xg = GaussQuadrature::getCoord(nGauss); const double* wg = GaussQuadrature::getWeight(nGauss); if (!xg || !wg) return false; // Find the parametric direction of the face normal {-3,-2,-1, 1, 2, 3} const int faceDir = (lIndex+1)/(lIndex%2 ? -2 : 2); const int t1 = 1 + abs(faceDir)%3; // first tangent direction const int t2 = 1 + t1%3; // second tangent direction // Compute parameter values of the Gauss points over the whole patch face std::array<Matrix,3> gpar; for (int d = 0; d < 3; d++) if (-1-d == faceDir) { gpar[d].resize(1,1); gpar[d].fill(svol->startparam(d)); } else if (1+d == faceDir) { gpar[d].resize(1,1); gpar[d].fill(svol->endparam(d)); } else this->getGaussPointParameters(gpar[d],d,nGauss,xg); // Evaluate basis function derivatives at all integration points std::vector<std::vector<Go::BasisDerivs>> splinex(m_basis.size()); #pragma omp parallel for schedule(static) for (size_t i = 0; i < m_basis.size(); ++i) m_basis[i]->computeBasisGrid(gpar[0],gpar[1],gpar[2],splinex[i]); const int n1 = svol->numCoefs(0); const int n2 = svol->numCoefs(1); const int p1 = svol->order(0); const int p2 = svol->order(1); const int p3 = svol->order(2); std::vector<size_t> elem_sizes; for (auto& it : m_basis) elem_sizes.push_back(it->order(0)*it->order(1)*it->order(2)); const int nel1 = n1 - p1 + 1; const int nel2 = n2 - p2 + 1; std::map<char,size_t>::const_iterator iit = firstBp.find(lIndex); size_t firstp = iit == firstBp.end() ? 0 : iit->second; // === Assembly loop over all elements on the patch face ===================== bool ok = true; for (size_t g = 0; g < threadGrp.size() && ok; ++g) { #pragma omp parallel for schedule(static) for (size_t t = 0; t < threadGrp[g].size(); ++t) { MxFiniteElement fe(elem_sizes); fe.xi = fe.eta = fe.zeta = faceDir < 0 ? -1.0 : 1.0; fe.u = gpar[0](1,1); fe.v = gpar[1](1,1); fe.w = gpar[2](1,1); std::vector<Matrix> dNxdu(m_basis.size()); Matrix Xnod, Jac; Vec4 X; Vec3 normal; for (size_t l = 0; l < threadGrp[g][t].size() && ok; ++l) { int iel = threadGrp[g][t][l]; fe.iel = MLGE[iel]; if (fe.iel < 1) continue; // zero-volume element int i1 = p1 + iel % nel1; int i2 = p2 + (iel / nel1) % nel2; int i3 = p3 + iel / (nel1*nel2); // Get element face area in the parameter space double dA = this->getParametricArea(++iel,abs(faceDir)); if (dA < 0.0) // topology error (probably logic error) { ok = false; break; } // Set up control point coordinates for current element if (!this->getElementCoordinates(Xnod,iel)) { ok = false; break; } if (useElmVtx) this->getElementCorners(i1-1,i2-1,i3-1,fe.XC); // Initialize element quantities LocalIntegral* A = integrand.getLocalIntegral(elem_sizes,fe.iel,true); if (!integrand.initElementBou(MNPC[iel-1],elem_sizes,nb,*A)) { A->destruct(); ok = false; break; } // Define some loop control variables depending on which face we are on int nf1, j1, j2; switch (abs(faceDir)) { case 1: nf1 = nel2; j2 = i3-p3; j1 = i2-p2; break; case 2: nf1 = nel1; j2 = i3-p3; j1 = i1-p1; break; case 3: nf1 = nel1; j2 = i2-p2; j1 = i1-p1; break; default: nf1 = j1 = j2 = 0; } // --- Integration loop over all Gauss points in each direction -------- int k1, k2, k3; int ip = (j2*nGauss*nf1 + j1)*nGauss; int jp = (j2*nf1 + j1)*nGauss*nGauss; fe.iGP = firstp + jp; // Global integration point counter for (int j = 0; j < nGauss; j++, ip += nGauss*(nf1-1)) for (int i = 0; i < nGauss; i++, ip++, fe.iGP++) { // Local element coordinates and parameter values // of current integration point switch (abs(faceDir)) { case 1: k2 = i; k3 = j; k1 = 0; break; case 2: k1 = i; k3 = j; k2 = 0; break; case 3: k1 = i; k2 = j; k3 = 0; break; default: k1 = k2 = k3 = 0; } if (gpar[0].size() > 1) { fe.xi = xg[k1]; fe.u = gpar[0](k1+1,i1-p1+1); } if (gpar[1].size() > 1) { fe.eta = xg[k2]; fe.v = gpar[1](k2+1,i2-p2+1); } if (gpar[2].size() > 1) { fe.zeta = xg[k3]; fe.w = gpar[2](k3+1,i3-p3+1); } // Fetch basis function derivatives at current integration point for (size_t b = 0; b < m_basis.size(); ++b) SplineUtils::extractBasis(splinex[b][ip],fe.basis(b+1),dNxdu[b]); // Compute Jacobian inverse of the coordinate mapping and // basis function derivatives w.r.t. Cartesian coordinates fe.detJxW = utl::Jacobian(Jac,normal,fe.grad(geoBasis),Xnod,dNxdu[geoBasis-1],t1,t2); if (fe.detJxW == 0.0) continue; // skip singular points for (size_t b = 0; b < m_basis.size(); ++b) if (b != (size_t)geoBasis-1) fe.grad(b+1).multiply(dNxdu[b],Jac); if (faceDir < 0) normal *= -1.0; // Cartesian coordinates of current integration point X = Xnod * fe.basis(geoBasis); X.t = time.t; // Evaluate the integrand and accumulate element contributions fe.detJxW *= 0.25*dA*wg[i]*wg[j]; if (!integrand.evalBouMx(*A,fe,time,X,normal)) ok = false; } // Finalize the element quantities if (ok && !integrand.finalizeElementBou(*A,fe,time)) ok = false; // Assembly of global system integral if (ok && !glInt.assemble(A->ref(),fe.iel)) ok = false; A->destruct(); } } } return ok; }
bool ASMs3Dmx::integrate (Integrand& integrand, GlobalIntegral& glInt, const TimeDomain& time) { if (!svol) return true; // silently ignore empty patches if (m_basis.empty()) return false; PROFILE2("ASMs3Dmx::integrate(I)"); bool use2ndDer = integrand.getIntegrandType() & Integrand::SECOND_DERIVATIVES; bool useElmVtx = integrand.getIntegrandType() & Integrand::ELEMENT_CORNERS; // Get Gaussian quadrature points and weights const double* xg = GaussQuadrature::getCoord(nGauss); const double* wg = GaussQuadrature::getWeight(nGauss); if (!xg || !wg) return false; // Compute parameter values of the Gauss points over the whole patch std::array<Matrix,3> gpar; for (int d = 0; d < 3; d++) this->getGaussPointParameters(gpar[d],d,nGauss,xg); // Evaluate basis function derivatives at all integration points std::vector<std::vector<Go::BasisDerivs>> splinex(m_basis.size()); std::vector<std::vector<Go::BasisDerivs2>> splinex2(m_basis.size()); if (use2ndDer) { #pragma omp parallel for schedule(static) for (size_t i=0;i<m_basis.size();++i) m_basis[i]->computeBasisGrid(gpar[0],gpar[1],gpar[2],splinex2[i]); } else { #pragma omp parallel for schedule(static) for (size_t i=0;i<m_basis.size();++i) m_basis[i]->computeBasisGrid(gpar[0],gpar[1],gpar[2],splinex[i]); } std::vector<size_t> elem_sizes; for (auto& it : m_basis) elem_sizes.push_back(it->order(0)*it->order(1)*it->order(2)); const int p1 = svol->order(0); const int p2 = svol->order(1); const int p3 = svol->order(2); const int n1 = svol->numCoefs(0); const int n2 = svol->numCoefs(1); const int n3 = svol->numCoefs(2); const int nel1 = n1 - p1 + 1; const int nel2 = n2 - p2 + 1; const int nel3 = n3 - p3 + 1; // === Assembly loop over all elements in the patch ========================== bool ok=true; for (size_t g=0;g<threadGroupsVol.size() && ok;++g) { #pragma omp parallel for schedule(static) for (size_t t=0;t<threadGroupsVol[g].size();++t) { MxFiniteElement fe(elem_sizes); std::vector<Matrix> dNxdu(m_basis.size()); std::vector<Matrix3D> d2Nxdu2(m_basis.size()); Matrix3D Hess; double dXidu[3]; Matrix Xnod, Jac; Vec4 X; for (size_t l = 0; l < threadGroupsVol[g][t].size() && ok; ++l) { int iel = threadGroupsVol[g][t][l]; fe.iel = MLGE[iel]; if (fe.iel < 1) continue; // zero-volume element int i1 = p1 + iel % nel1; int i2 = p2 + (iel / nel1) % nel3; int i3 = p3 + iel / (nel1*nel2); // Get element volume in the parameter space double dV = this->getParametricVolume(++iel); if (dV < 0.0) // topology error (probably logic error) { ok = false; break; } // Set up control point (nodal) coordinates for current element if (!this->getElementCoordinates(Xnod,iel)) { ok = false; break; } if (useElmVtx) this->getElementCorners(i1-1,i2-1,i3-1,fe.XC); if (integrand.getIntegrandType() & Integrand::G_MATRIX) { // Element size in parametric space dXidu[0] = svol->knotSpan(0,i1-1); dXidu[1] = svol->knotSpan(1,i2-1); dXidu[2] = svol->knotSpan(2,i3-1); } // Initialize element quantities LocalIntegral* A = integrand.getLocalIntegral(elem_sizes,fe.iel,false); if (!integrand.initElement(MNPC[iel-1],elem_sizes,nb,*A)) { A->destruct(); ok = false; break; } // --- Integration loop over all Gauss points in each direction -------- int ip = (((i3-p3)*nGauss*nel2 + i2-p2)*nGauss*nel1 + i1-p1)*nGauss; int jp = (((i3-p3)*nel2 + i2-p2*nel1 + i1-p1))*nGauss*nGauss*nGauss; fe.iGP = firstIp + jp; // Global integration point counter for (int k = 0; k < nGauss; k++, ip += nGauss*(nel2-1)*nGauss*nel1) for (int j = 0; j < nGauss; j++, ip += nGauss*(nel1-1)) for (int i = 0; i < nGauss; i++, ip++, fe.iGP++) { // Local element coordinates of current integration point fe.xi = xg[i]; fe.eta = xg[j]; fe.zeta = xg[k]; // Parameter values of current integration point fe.u = gpar[0](i+1,i1-p1+1); fe.v = gpar[1](j+1,i2-p2+1); fe.w = gpar[2](k+1,i3-p3+1); // Fetch basis function derivatives at current integration point if (use2ndDer) { for (size_t b = 0; b < m_basis.size(); ++b) SplineUtils::extractBasis(splinex2[b][ip],fe.basis(b+1),dNxdu[b], d2Nxdu2[b]); } else { for (size_t b = 0; b < m_basis.size(); ++b) SplineUtils::extractBasis(splinex[b][ip],fe.basis(b+1),dNxdu[b]); } // Compute Jacobian inverse of the coordinate mapping and // basis function derivatives w.r.t. Cartesian coordinates fe.detJxW = utl::Jacobian(Jac,fe.grad(geoBasis),Xnod, dNxdu[geoBasis-1]); if (fe.detJxW == 0.0) continue; // skip singular points for (size_t b = 0; b < m_basis.size(); ++b) if (b != (size_t)geoBasis-1) fe.grad(b+1).multiply(dNxdu[b],Jac); // Compute Hessian of coordinate mapping and 2nd order derivatives if (use2ndDer) { if (!utl::Hessian(Hess,fe.hess(geoBasis),Jac,Xnod, d2Nxdu2[geoBasis-1],fe.grad(geoBasis),true)) ok = false; for (size_t b = 0; b < m_basis.size() && ok; ++b) if ((int)b != geoBasis) if (!utl::Hessian(Hess,fe.hess(b+1),Jac,Xnod, d2Nxdu2[b],fe.grad(b+1),false)) ok = false; } // Compute G-matrix if (integrand.getIntegrandType() & Integrand::G_MATRIX) utl::getGmat(Jac,dXidu,fe.G); // Cartesian coordinates of current integration point X = Xnod * fe.basis(geoBasis); X.t = time.t; // Evaluate the integrand and accumulate element contributions fe.detJxW *= 0.125*dV*wg[i]*wg[j]*wg[k]; if (!integrand.evalIntMx(*A,fe,time,X)) ok = false; } // Finalize the element quantities if (ok && !integrand.finalizeElement(*A,time,firstIp+jp)) ok = false; // Assembly of global system integral if (ok && !glInt.assemble(A->ref(),fe.iel)) ok = false; A->destruct(); } } } return ok; }
bool ASMs2DmxLag::evalSolution (Matrix& sField, const IntegrandBase& integrand, const RealArray*, bool) const { sField.resize(0,0); double incx = 2.0/double(p1-1); double incy = 2.0/double(p2-1); size_t nPoints = nb[0]; IntVec check(nPoints,0); MxFiniteElement fe(elem_size); Vector solPt; Vectors globSolPt(nPoints); Matrices dNxdu(nxx.size()); Matrix Xnod, Jac; // Evaluate the secondary solution field at each point for (size_t iel = 1; iel <= nel; iel++) { IntVec::const_iterator f2start = geoBasis == 1? MNPC[iel-1].begin() : MNPC[iel-1].begin() + std::accumulate(elem_size.begin()+geoBasis-2, elem_size.begin()+geoBasis-1, 0); IntVec::const_iterator f2end = f2start + elem_size[geoBasis-1]; IntVec mnpc1(f2start,f2end); this->getElementCoordinates(Xnod,iel); int i, j, loc = 0; for (j = 0; j < p2; j++) for (i = 0; i < p1; i++, loc++) { double xi = -1.0 + i*incx; double eta = -1.0 + j*incy; for (size_t b = 0; b < nxx.size(); ++b) if (!Lagrange::computeBasis(fe.basis(b+1),dNxdu[b],elem_sizes[b][0],xi, elem_sizes[b][1],eta)) return false; // Compute the Jacobian inverse fe.detJxW = utl::Jacobian(Jac,fe.grad(geoBasis),Xnod,dNxdu[geoBasis-1]); for (size_t b = 1; b <= nxx.size(); b++) if (b != (size_t)geoBasis) { if (fe.detJxW == 0.0) fe.grad(b).clear(); else fe.grad(b).multiply(dNxdu[b-1],Jac); } // Now evaluate the solution field if (!integrand.evalSol(solPt,fe,Xnod*fe.basis(geoBasis),MNPC[iel-1],elem_size,nb)) return false; else if (sField.empty()) sField.resize(solPt.size(),nPoints,true); if (++check[mnpc1[loc]] == 1) globSolPt[mnpc1[loc]] = solPt; else globSolPt[mnpc1[loc]] += solPt; } } for (size_t i = 0; i < nPoints; i++) sField.fillColumn(1+i,globSolPt[i] /= check[i]); return true; }
bool ASMs2DmxLag::integrate (Integrand& integrand, int lIndex, GlobalIntegral& glInt, const TimeDomain& time) { if (this->empty()) return true; // silently ignore empty patches // Get Gaussian quadrature points and weights const double* xg = GaussQuadrature::getCoord(nGauss); const double* wg = GaussQuadrature::getWeight(nGauss); if (!xg || !wg) return false; // Find the parametric direction of the edge normal {-2,-1, 1, 2} const int edgeDir = (lIndex%10+1)/((lIndex%2) ? -2 : 2); const int t1 = abs(edgeDir); // tangent direction normal to the patch edge const int t2 = 3-t1; // tangent direction along the patch edge // Extract the Neumann order flag (1 or higher) for the integrand integrand.setNeumannOrder(1 + lIndex/10); // Number of elements in each direction const int nelx = (nxx[geoBasis-1]-1)/(elem_sizes[geoBasis-1][0]-1); const int nely = (nyx[geoBasis-1]-1)/(elem_sizes[geoBasis-1][1]-1); std::map<char,size_t>::const_iterator iit = firstBp.find(lIndex%10); size_t firstp = iit == firstBp.end() ? 0 : iit->second; MxFiniteElement fe(elem_size); Matrices dNxdu(nxx.size()); Matrix Xnod, Jac; Vec4 X; Vec3 normal; double xi[2]; // === Assembly loop over all elements on the patch edge ===================== int iel = 1; for (int i2 = 0; i2 < nely; i2++) for (int i1 = 0; i1 < nelx; i1++, iel++) { // Skip elements that are not on current boundary edge bool skipMe = false; switch (edgeDir) { case -1: if (i1 > 0) skipMe = true; break; case 1: if (i1 < nelx-1) skipMe = true; break; case -2: if (i2 > 0) skipMe = true; break; case 2: if (i2 < nely-1) skipMe = true; break; } if (skipMe) continue; // Set up control point coordinates for current element if (!this->getElementCoordinates(Xnod,iel)) return false; // Initialize element quantities fe.iel = MLGE[iel-1]; LocalIntegral* A = integrand.getLocalIntegral(elem_size,fe.iel,true); bool ok = integrand.initElementBou(MNPC[iel-1],elem_size,nb,*A); // --- Integration loop over all Gauss points along the edge ------------- int jp = (t1 == 1 ? i2 : i1)*nGauss; fe.iGP = firstp + jp; // Global integration point counter for (int i = 0; i < nGauss && ok; i++, fe.iGP++) { // Gauss point coordinates along the edge xi[t1-1] = edgeDir < 0 ? -1.0 : 1.0; xi[t2-1] = xg[i]; // Compute the basis functions and their derivatives, using // tensor product of one-dimensional Lagrange polynomials for (size_t b = 0; b < nxx.size(); ++b) if (!Lagrange::computeBasis(fe.basis(b+1),dNxdu[b],elem_sizes[b][0],xi[0], elem_sizes[b][1],xi[1])) ok = false; // Compute basis function derivatives and the edge normal fe.detJxW = utl::Jacobian(Jac,normal,fe.grad(geoBasis),Xnod,dNxdu[geoBasis-1],t1,t2); if (fe.detJxW == 0.0) continue; // skip singular points for (size_t b = 0; b < nxx.size(); ++b) if (b != (size_t)geoBasis-1) fe.grad(b+1).multiply(dNxdu[b],Jac); if (edgeDir < 0) normal *= -1.0; // Cartesian coordinates of current integration point X = Xnod * fe.basis(geoBasis); X.t = time.t; // Evaluate the integrand and accumulate element contributions fe.detJxW *= wg[i]; if (ok && !integrand.evalBouMx(*A,fe,time,X,normal)) ok = false; } // Finalize the element quantities if (ok && !integrand.finalizeElementBou(*A,fe,time)) ok = false; // Assembly of global system integral if (ok && !glInt.assemble(A->ref(),fe.iel)) ok = false; A->destruct(); if (!ok) return false; } return true; }
bool ASMs2DmxLag::integrate (Integrand& integrand, GlobalIntegral& glInt, const TimeDomain& time) { if (this->empty()) return true; // silently ignore empty patches // Get Gaussian quadrature points and weights const double* xg = GaussQuadrature::getCoord(nGauss); const double* wg = GaussQuadrature::getWeight(nGauss); if (!xg || !wg) return false; // Get parametric coordinates of the elements RealArray upar, vpar; this->getGridParameters(upar,0,1); this->getGridParameters(vpar,1,1); const int nelx = upar.size() - 1; // === Assembly loop over all elements in the patch ========================== bool ok = true; for (size_t g = 0; g < threadGroups.size() && ok; g++) { #pragma omp parallel for schedule(static) for (size_t t = 0; t < threadGroups[g].size(); t++) { MxFiniteElement fe(elem_size); Matrices dNxdu(nxx.size()); Matrix Xnod, Jac; Vec4 X; for (size_t i = 0; i < threadGroups[g][t].size() && ok; ++i) { int iel = threadGroups[g][t][i]; int i1 = iel % nelx; int i2 = iel / nelx; // Set up control point coordinates for current element if (!this->getElementCoordinates(Xnod,++iel)) { ok = false; break; } // Initialize element quantities fe.iel = MLGE[iel-1]; LocalIntegral* A = integrand.getLocalIntegral(elem_size,fe.iel,false); if (!integrand.initElement(MNPC[iel-1],elem_size,nb,*A)) { A->destruct(); ok = false; break; } // --- Integration loop over all Gauss points in each direction -------- int jp = (i2*nelx + i1)*nGauss*nGauss; fe.iGP = firstIp + jp; // Global integration point counter for (int j = 0; j < nGauss; j++) for (int i = 0; i < nGauss; i++, fe.iGP++) { // Parameter value of current integration point fe.u = 0.5*(upar[i1]*(1.0-xg[i]) + upar[i1+1]*(1.0+xg[i])); fe.v = 0.5*(vpar[i2]*(1.0-xg[j]) + vpar[i2+1]*(1.0+xg[j])); // Local coordinates of current integration point fe.xi = xg[i]; fe.eta = xg[j]; // Compute basis function derivatives at current integration point // using tensor product of one-dimensional Lagrange polynomials for (size_t b = 0; b < nxx.size(); ++b) if (!Lagrange::computeBasis(fe.basis(b+1),dNxdu[b],elem_sizes[b][0],xg[i], elem_sizes[b][1],xg[j])) ok = false; // Compute Jacobian inverse of coordinate mapping and derivatives fe.detJxW = utl::Jacobian(Jac,fe.grad(geoBasis),Xnod,dNxdu[geoBasis-1]); if (fe.detJxW == 0.0) continue; // skip singular points for (size_t b = 0; b < nxx.size(); ++b) if (b != (size_t)geoBasis-1) fe.grad(b+1).multiply(dNxdu[b],Jac); // Cartesian coordinates of current integration point X = Xnod * fe.basis(geoBasis); X.t = time.t; // Evaluate the integrand and accumulate element contributions fe.detJxW *= wg[i]*wg[j]; if (!integrand.evalIntMx(*A,fe,time,X)) ok = false; } // Finalize the element quantities if (ok && !integrand.finalizeElement(*A,time,firstIp+jp)) ok = false; // Assembly of global system integral if (ok && !glInt.assemble(A->ref(),fe.iel)) ok = false; A->destruct(); } } } return ok; }