bool ASMs1D::integrate (Integrand& integrand,
GlobalIntegral& glInt,
const TimeDomain& time)
{
if (!curv) 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 the reduced integration quadrature points, if needed
const double* xr = nullptr;
const double* wr = nullptr;
int nRed = integrand.getReducedIntegration(nGauss);
if (nRed > 0)
{
xr = GaussQuadrature::getCoord(nRed);
wr = GaussQuadrature::getWeight(nRed);
if (!xr || !wr) return false;
}
else if (nRed < 0)
nRed = nGauss; // The integrand needs to know nGauss
if (integrand.getIntegrandType() & Integrand::SECOND_DERIVATIVES)
if (curv->rational())
{
std::cerr <<" *** ASMs1D::integrate: Second-derivatives of NURBS "
<<" is not implemented yet, sorry..."<< std::endl;
return false;
}
// Compute parameter values of the Gauss points over the whole patch
Matrix gpar, redpar;
this->getGaussPointParameters(gpar,nGauss,xg);
if (xr)
this->getGaussPointParameters(redpar,nRed,xr);
const int p1 = curv->order();
FiniteElement fe(p1);
Matrix dNdu, Jac;
Matrix3D d2Ndu2, Hess;
Vec4 X;
if (nsd > 1 && (integrand.getIntegrandType() & Integrand::SECOND_DERIVATIVES))
fe.G.resize(nsd,2); // For storing d{X}/du and d2{X}/du2
// === Assembly loop over all elements in the patch ==========================
for (size_t iel = 0; iel < nel; iel++)
{
fe.iel = MLGE[iel];
if (fe.iel < 1) continue; // zero-length element
// Check that the current element has nonzero length
double dL = this->getParametricLength(1+iel);
if (dL < 0.0) return false; // topology error (probably logic error)
// Set up control point coordinates for current element
if (!this->getElementCoordinates(fe.Xn,1+iel)) return false;
if (integrand.getIntegrandType() & Integrand::ELEMENT_CORNERS)
this->getElementEnds(p1+iel,fe.XC);
if (integrand.getIntegrandType() & Integrand::NODAL_ROTATIONS)
{
this->getElementNodalRotations(fe.Tn,iel);
if (!elmCS.empty()) fe.Te = elmCS[iel];
}
// Initialize element matrices
LocalIntegral* A = integrand.getLocalIntegral(fe.N.size(),fe.iel);
bool ok = integrand.initElement(MNPC[iel],fe,X,nRed,*A);
if (xr)
{
// --- Selective reduced integration loop --------------------------------
for (int i = 0; i < nRed && ok; i++)
{
// Local element coordinates of current integration point
fe.xi = xr[i];
// Parameter values of current integration point
fe.u = redpar(1+i,1+iel);
if (integrand.getIntegrandType() & Integrand::NO_DERIVATIVES)
this->extractBasis(fe.u,fe.N);
else
{
// Fetch basis function derivatives at current point
this->extractBasis(fe.u,fe.N,dNdu);
// Compute Jacobian inverse and derivatives
dNdu.multiply(0.5*dL); // Derivatives w.r.t. xi=[-1,1]
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,fe.Xn,dNdu)*wr[i];
}
// Cartesian coordinates of current integration point
X = fe.Xn * fe.N;
X.t = time.t;
// Compute the reduced integration terms of the integrand
ok = integrand.reducedInt(*A,fe,X);
}
}
// --- Integration loop over all Gauss points in current element -----------
int jp = iel*nGauss;
fe.iGP = firstIp + jp; // Global integration point counter
for (int i = 0; i < nGauss && ok; i++, fe.iGP++)
{
// Local element coordinate of current integration point
fe.xi = xg[i];
// Parameter value of current integration point
fe.u = gpar(1+i,1+iel);
// Compute basis functions and derivatives
if (integrand.getIntegrandType() & Integrand::NO_DERIVATIVES)
this->extractBasis(fe.u,fe.N);
else if (integrand.getIntegrandType() & Integrand::SECOND_DERIVATIVES)
this->extractBasis(fe.u,fe.N,dNdu,d2Ndu2);
else
this->extractBasis(fe.u,fe.N,dNdu);
if (!dNdu.empty())
{
// Compute derivatives in terms of physical coordinates
dNdu.multiply(0.5*dL); // Derivatives w.r.t. xi=[-1,1]
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,fe.Xn,dNdu)*wg[i];
if (fe.detJxW == 0.0) continue; // skip singular points
// Compute Hessian of coordinate mapping and 2nd order derivatives
if (integrand.getIntegrandType() & Integrand::SECOND_DERIVATIVES)
{
d2Ndu2.multiply(0.25*dL*dL); // 2nd derivatives w.r.t. xi=[-1,1]
if (!utl::Hessian(Hess,fe.d2NdX2,Jac,fe.Xn,d2Ndu2,fe.dNdX))
ok = false;
else if (fe.G.cols() == 2)
{
// Store the first and second derivatives of {X} w.r.t.
// the parametric coordinate (xi), in the G-matrix
fe.G.fillColumn(1,Jac.ptr());
fe.G.fillColumn(2,Hess.ptr());
}
}
}
// Cartesian coordinates of current integration point
X = fe.Xn * fe.N;
X.t = time.t;
// Evaluate the integrand and accumulate element contributions
if (ok && !integrand.evalInt(*A,fe,time,X))
ok = false;
}
// Finalize the element quantities
if (ok && !integrand.finalizeElement(*A,fe,time,firstIp+jp))
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 ASMs3DLag::integrate (Integrand& integrand,
GlobalIntegral& glInt,
const TimeDomain& time)
{
if (!svol) 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 the reduced integration quadrature points, if needed
const double* xr = nullptr;
const double* wr = nullptr;
int nRed = integrand.getReducedIntegration(nGauss);
if (nRed > 0)
{
xr = GaussQuadrature::getCoord(nRed);
wr = GaussQuadrature::getWeight(nRed);
if (!xr || !wr) return false;
}
else if (nRed < 0)
nRed = nGauss; // The integrand needs to know nGauss
// Get parametric coordinates of the elements
RealArray upar, vpar, wpar;
this->getGridParameters(upar,0,1);
this->getGridParameters(vpar,1,1);
this->getGridParameters(wpar,2,1);
// Number of elements in each direction
const int nel1 = upar.size() - 1;
const int nel2 = vpar.size() - 1;
// Order of basis in the three parametric directions (order = degree + 1)
const int p1 = svol->order(0);
const int p2 = svol->order(1);
const int p3 = svol->order(2);
// === 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++)
{
FiniteElement fe(p1*p2*p3);
Matrix dNdu, Xnod, Jac;
Vec4 X;
for (size_t l = 0; l < threadGroupsVol[g][t].size() && ok; l++)
{
int iel = threadGroupsVol[g][t][l];
int i1 = iel % nel1;
int i2 = (iel / nel1) % nel2;
int i3 = iel / (nel1*nel2);
// Set up nodal point coordinates for current element
if (!this->getElementCoordinates(Xnod,++iel))
{
ok = false;
break;
}
if (integrand.getIntegrandType() & Integrand::ELEMENT_CENTER)
{
// Compute the element "center" (average of element node coordinates)
X = 0.0;
for (size_t i = 1; i <= 3; i++)
for (size_t j = 1; j <= Xnod.cols(); j++)
X[i-1] += Xnod(i,j);
X *= 1.0/(double)Xnod.cols();
}
// Initialize element quantities
fe.iel = MLGE[iel-1];
LocalIntegral* A = integrand.getLocalIntegral(fe.N.size(),fe.iel);
if (!integrand.initElement(MNPC[iel-1],fe,X,nRed*nRed*nRed,*A))
{
A->destruct();
ok = false;
break;
}
if (xr)
{
// --- Selective reduced integration loop ----------------------------
for (int k = 0; k < nRed; k++)
for (int j = 0; j < nRed; j++)
for (int i = 0; i < nRed; i++)
{
// Local element coordinates of current integration point
fe.xi = xr[i];
fe.eta = xr[j];
fe.zeta = xr[k];
// Parameter value of current integration point
fe.u = 0.5*(upar[i1]*(1.0-xr[i]) + upar[i1+1]*(1.0+xr[i]));
fe.v = 0.5*(vpar[i2]*(1.0-xr[j]) + vpar[i2+1]*(1.0+xr[j]));
fe.w = 0.5*(wpar[i3]*(1.0-xr[k]) + wpar[i3+1]*(1.0+xr[k]));
// Compute basis function derivatives at current point
// using tensor product of one-dimensional Lagrange polynomials
if (!Lagrange::computeBasis(fe.N,dNdu,
p1,xr[i],p2,xr[j],p3,xr[k]))
{
ok = false;
break;
}
// Compute Jacobian inverse and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
// Cartesian coordinates of current integration point
X = Xnod * fe.N;
X.t = time.t;
// Compute the reduced integration terms of the integrand
fe.detJxW *= wr[i]*wr[j]*wr[k];
if (!integrand.reducedInt(*A,fe,X))
ok = false;
}
}
// --- Integration loop over all Gauss points in each direction --------
int jp = ((i3*nel2 + i2)*nel1 + i1)*nGauss*nGauss*nGauss;
fe.iGP = firstIp + jp; // Global integration point counter
for (int k = 0; k < nGauss; k++)
for (int j = 0; j < nGauss; j++)
for (int i = 0; i < nGauss; i++, fe.iGP++)
{
// Local element coordinates of current integration point
fe.xi = xg[i];
fe.eta = xg[j];
fe.zeta = xg[k];
// 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]));
fe.w = 0.5*(wpar[i3]*(1.0-xg[k]) + wpar[i3+1]*(1.0+xg[k]));
// Compute basis function derivatives at current integration point
// using tensor product of one-dimensional Lagrange polynomials
if (!Lagrange::computeBasis(fe.N,dNdu,p1,xg[i],p2,xg[j],p3,xg[k]))
ok = false;
// Compute Jacobian inverse of coordinate mapping and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
if (fe.detJxW == 0.0) continue; // skip singular points
// Cartesian coordinates of current integration point
X = Xnod * fe.N;
X.t = time.t;
// Evaluate the integrand and accumulate element contributions
fe.detJxW *= wg[i]*wg[j]*wg[k];
if (!integrand.evalInt(*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 ASMs1DSpec::integrate (Integrand& integrand,
GlobalIntegral& glInt,
const TimeDomain& time)
{
if (!curv) return true; // silently ignore empty patches
// Order of basis (order = degree + 1)
const int p1 = curv->order();
const int n1 = nGauss < 1 ? p1 : nGauss;
// Evaluate integration points and weights
Vector wg1, xg1, points1;
if (!Legendre::GLL(wg1,points1,p1))
return false;
Matrix D1;
if (nGauss < 1)
{
// We are using the nodal points themselves as integration points
if (!Legendre::basisDerivatives(n1,D1))
return false;
}
else
// Using Gauss-Legendre scheme with nGauss points
if (!Legendre::GL(wg1,xg1,n1))
return false;
FiniteElement fe(p1);
Matrix dNdu, Xnod, Jac;
Vec4 X;
// === Assembly loop over all elements in the patch ==========================
const int nel = this->getNoElms();
for (int iel = 1; iel <= nel; iel++)
{
// 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(p1,fe.iel);
if (!integrand.initElement(MNPC[iel-1],*A)) return false;
// --- Integration loop over integration points ----------------------------
for (int i = 0; i < n1; i++)
{
// Compute basis function derivatives at current integration point
if (nGauss < 1)
{
fe.N.fill(0.0);
fe.N(i+1) = 1.0;
dNdu.fillColumn(1,D1.getRow(i+1));
}
else
if (!Lagrange::computeBasis(fe.N,&dNdu,points1,xg1[i]))
return false;
// Compute Jacobian inverse of coordinate mapping and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
// Cartesian coordinates of current integration point
X = Xnod*fe.N;
X.t = time.t;
// Evaluate the integrand and accumulate element contributions
fe.detJxW *= wg1[i];
if (!integrand.evalInt(*A,fe,time,X))
return false;
}
// Assembly of global system integral
if (!glInt.assemble(A->ref(),fe.iel))
return false;
A->destruct();
}
return true;
}
bool ASMs2DLag::integrate (Integrand& integrand,
GlobalIntegral& glInt,
const TimeDomain& time)
{
if (this->empty()) return true; // silently ignore empty patches
// Get Gaussian quadrature points and weights
std::array<int,2> ng;
std::array<const double*,2> xg, wg;
for (int d = 0; d < 2; d++)
{
ng[d] = this->getNoGaussPt(d == 0 ? p1 : p2);
xg[d] = GaussQuadrature::getCoord(ng[d]);
wg[d] = GaussQuadrature::getWeight(ng[d]);
if (!xg[d] || !wg[d]) return false;
}
// Get the reduced integration quadrature points, if needed
const double* xr = nullptr;
const double* wr = nullptr;
int nRed = integrand.getReducedIntegration(ng[0]);
if (nRed > 0)
{
xr = GaussQuadrature::getCoord(nRed);
wr = GaussQuadrature::getWeight(nRed);
if (!xr || !wr) return false;
}
else if (nRed < 0)
nRed = ng[0]; // The integrand needs to know nGauss
// Get parametric coordinates of the elements
RealArray upar, vpar;
this->getGridParameters(upar,0,1);
this->getGridParameters(vpar,1,1);
// Number of elements in each direction
const int nelx = upar.empty() ? 0 : 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++)
{
FiniteElement fe(p1*p2);
Matrix dNdu, Xnod, Jac;
Vec4 X;
for (size_t i = 0; i < threadGroups[g][t].size() && ok; i++)
{
int iel = threadGroups[g][t][i];
int i1 = nelx > 0 ? iel % nelx : 0;
int i2 = nelx > 0 ? iel / nelx : 0;
// Set up nodal point coordinates for current element
if (!this->getElementCoordinates(Xnod,1+iel))
{
ok = false;
break;
}
if (integrand.getIntegrandType() & Integrand::ELEMENT_CENTER)
{
// Compute the element "center" (average of element node coordinates)
X = 0.0;
for (size_t i = 1; i <= nsd; i++)
for (size_t j = 1; j <= Xnod.cols(); j++)
X[i-1] += Xnod(i,j);
X *= 1.0/(double)Xnod.cols();
}
// Initialize element quantities
fe.iel = MLGE[iel];
LocalIntegral* A = integrand.getLocalIntegral(fe.N.size(),fe.iel);
if (!integrand.initElement(MNPC[iel],fe,X,nRed*nRed,*A))
{
A->destruct();
ok = false;
break;
}
if (xr)
{
// --- Selective reduced integration loop ----------------------------
for (int j = 0; j < nRed; j++)
for (int i = 0; i < nRed; i++)
{
// Local element coordinates of current integration point
fe.xi = xr[i];
fe.eta = xr[j];
// Parameter value of current integration point
if (!upar.empty())
fe.u = 0.5*(upar[i1]*(1.0-xr[i]) + upar[i1+1]*(1.0+xr[i]));
if (!vpar.empty())
fe.v = 0.5*(vpar[i2]*(1.0-xr[j]) + vpar[i2+1]*(1.0+xr[j]));
// Compute basis function derivatives at current point
// using tensor product of one-dimensional Lagrange polynomials
if (!Lagrange::computeBasis(fe.N,dNdu,p1,xr[i],p2,xr[j]))
ok = false;
// Compute Jacobian inverse and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
// Cartesian coordinates of current integration point
X = Xnod * fe.N;
X.t = time.t;
// Compute the reduced integration terms of the integrand
fe.detJxW *= wr[i]*wr[j];
if (!integrand.reducedInt(*A,fe,X))
ok = false;
}
}
// --- Integration loop over all Gauss points in each direction --------
int jp = iel*ng[0]*ng[1];
fe.iGP = firstIp + jp; // Global integration point counter
for (int j = 0; j < ng[1]; j++)
for (int i = 0; i < ng[0]; i++, fe.iGP++)
{
// Local element coordinates of current integration point
fe.xi = xg[0][i];
fe.eta = xg[1][j];
// Parameter value of current integration point
if (!upar.empty())
fe.u = 0.5*(upar[i1]*(1.0-xg[0][i]) + upar[i1+1]*(1.0+xg[0][i]));
if (!vpar.empty())
fe.v = 0.5*(vpar[i2]*(1.0-xg[1][j]) + vpar[i2+1]*(1.0+xg[1][j]));
// Compute basis function derivatives at current integration point
// using tensor product of one-dimensional Lagrange polynomials
if (!Lagrange::computeBasis(fe.N,dNdu,p1,xg[0][i],p2,xg[1][j]))
ok = false;
// Compute Jacobian inverse of coordinate mapping and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
if (fe.detJxW == 0.0) continue; // skip singular points
// Cartesian coordinates of current integration point
X = Xnod * fe.N;
X.t = time.t;
// Evaluate the integrand and accumulate element contributions
fe.detJxW *= wg[0][i]*wg[1][j];
if (!integrand.evalInt(*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 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 ASMs2DSpec::integrate (Integrand& integrand,
GlobalIntegral& glInt,
const TimeDomain& time)
{
if (this->empty()) return true; // silently ignore empty patches
// Evaluate integration points (= nodal points) and weights
Vector wg1,xg1,wg2,xg2;
if (!Legendre::GLL(wg1,xg1,p1)) return false;
if (!Legendre::GLL(wg2,xg2,p2)) return false;
Matrix D1, D2;
if (!Legendre::basisDerivatives(p1,D1)) return false;
if (!Legendre::basisDerivatives(p2,D2)) return false;
// === 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++)
{
FiniteElement fe(p1*p2);
Matrix dNdu(p1*p2,2), Xnod, Jac;
Vec4 X;
for (size_t e = 0; e < threadGroups[g][t].size(); e++)
{
int iel = threadGroups[g][t][e]+1;
// 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(fe.N.size(),fe.iel);
if (!integrand.initElement(MNPC[iel-1],*A))
{
A->destruct();
ok = false;
break;
}
// --- Integration loop over all Gauss points in each direction --------
int count = 1;
for (int j = 1; j <= p2; j++)
for (int i = 1; i <= p1; i++, count++)
{
// Evaluate the basis functions and gradients using
// tensor product of one-dimensional Lagrange polynomials
evalBasis(i,j,p1,p2,D1,D2,fe.N,dNdu);
// Compute Jacobian inverse of coordinate mapping and derivatives
fe.detJxW = utl::Jacobian(Jac,fe.dNdX,Xnod,dNdu);
if (fe.detJxW == 0.0) continue; // skip singular points
// Cartesian coordinates of current integration point
X.x = Xnod(1,count);
X.y = Xnod(2,count);
X.t = time.t;
// Evaluate the integrand and accumulate element contributions
fe.detJxW *= wg1(i)*wg2(j);
if (!integrand.evalInt(*A,fe,time,X))
ok = false;
}
// Assembly of global system integral
if (ok && !glInt.assemble(A->ref(),fe.iel))
ok = false;
A->destruct();
}
}
}
return ok;
}
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;
}