polynomialBasis::polynomialBasis(int tag) : nodalBasis(tag)
{
switch(parentType) {
case TYPE_PNT: monomials = gmshGenerateMonomialsLine(0); break;
case TYPE_LIN: monomials = gmshGenerateMonomialsLine(order); break;
case TYPE_TRI:
monomials = gmshGenerateMonomialsTriangle(order, serendip);
break;
case TYPE_QUA:
monomials = serendip ? gmshGenerateMonomialsQuadSerendipity(order) :
gmshGenerateMonomialsQuadrangle(order);
break;
case TYPE_TET:
monomials = gmshGenerateMonomialsTetrahedron(order, serendip);
break;
case TYPE_PRI:
monomials = serendip ? gmshGenerateMonomialsPrismSerendipity(order) :
gmshGenerateMonomialsPrism(order);
break;
case TYPE_HEX:
monomials = serendip ? gmshGenerateMonomialsHexaSerendipity(order) :
gmshGenerateMonomialsHexahedron(order);
break;
}
coefficients = generateLagrangeMonomialCoefficients(monomials, points);
}
void bezierBasis::_construct(int parentType, int p)
{
order = p;
fullMatrix<double> exponents;
std::vector< fullMatrix<double> > subPoints;
if (parentType == TYPE_PYR) {
dim = 3;
numLagCoeff = 8;
exponents = JacobianBasis::generateJacMonomialsPyramid(order);
subPoints = generateSubPointsPyr(order);
numDivisions = static_cast<int>(subPoints.size());
fullMatrix<double> bezierPoints = exponents;
bezierPoints.scale(1. / (order + 2));
matrixBez2Lag = generateBez2LagMatrixPyramid(exponents, bezierPoints, order);
matrixBez2Lag.invert(matrixLag2Bez);
subDivisor = generateSubDivisorPyramid(exponents, subPoints, matrixLag2Bez, order);
return;
}
int dimSimplex;
switch (parentType) {
case TYPE_PNT :
dim = 0;
numLagCoeff = 1;
dimSimplex = 0;
exponents = gmshGenerateMonomialsLine(0);
subPoints.push_back(gmshGeneratePointsLine(0));
break;
case TYPE_LIN : {
dim = 1;
numLagCoeff = 2;
dimSimplex = 0;
exponents = gmshGenerateMonomialsLine(order);
subPoints = generateSubPointsLine(order);
break;
}
case TYPE_TRI : {
dim = 2;
numLagCoeff = 3;
dimSimplex = 2;
exponents = gmshGenerateMonomialsTriangle(order);
subPoints = generateSubPointsTriangle(order);
break;
}
case TYPE_QUA : {
dim = 2;
numLagCoeff = 4;
dimSimplex = 0;
exponents = gmshGenerateMonomialsQuadrangle(order);
subPoints = generateSubPointsQuad(order);
break;
}
case TYPE_TET : {
dim = 3;
numLagCoeff = 4;
dimSimplex = 3;
exponents = gmshGenerateMonomialsTetrahedron(order);
subPoints = generateSubPointsTetrahedron(order);
break;
}
case TYPE_PRI : {
dim = 3;
numLagCoeff = 6;
dimSimplex = 2;
exponents = gmshGenerateMonomialsPrism(order);
subPoints = generateSubPointsPrism(order);
break;
}
case TYPE_HEX : {
dim = 3;
numLagCoeff = 8;
dimSimplex = 0;
exponents = gmshGenerateMonomialsHexahedron(order);
subPoints = generateSubPointsHex(order);
break;
}
default : {
Msg::Error("Unknown function space of parentType %d : "
"reverting to TET_1", parentType);
dim = 3;
order = 0;
numLagCoeff = 4;
dimSimplex = 3;
exponents = gmshGenerateMonomialsTetrahedron(order);
subPoints = generateSubPointsTetrahedron(order);
break;
}
}
numDivisions = static_cast<int>(subPoints.size());
fullMatrix<double> bezierPoints = exponents;
bezierPoints.scale(1./order);
matrixBez2Lag = generateBez2LagMatrix(exponents, bezierPoints, order, dimSimplex);
matrixBez2Lag.invert(matrixLag2Bez);
subDivisor = generateSubDivisor(exponents, subPoints, matrixLag2Bez, order, dimSimplex);
}
fullMatrix<double> JacobianBasis::generateJacMonomialsPyramid(int order)
{
const int nbMonomials = (order+3)*(order+3)*(order+1);
fullMatrix<double> monomials(nbMonomials, 3);
if (order == 0) {
fullMatrix<double> prox, quad = gmshGenerateMonomialsQuadrangle(2);
prox.setAsProxy(monomials, 0, 2);
prox.setAll(quad);
// monomials has been initialized to 0, so third column is ok
return monomials;
}
monomials(0, 0) = 0;
monomials(0, 1) = 0;
monomials(0, 2) = 0;
monomials(1, 0) = order+2;
monomials(1, 1) = 0;
monomials(1, 2) = 0;
monomials(2, 0) = order+2;
monomials(2, 1) = order+2;
monomials(2, 2) = 0;
monomials(3, 0) = 0;
monomials(3, 1) = order+2;
monomials(3, 2) = 0;
monomials(4, 0) = 0;
monomials(4, 1) = 0;
monomials(4, 2) = order;
monomials(5, 0) = order+2;
monomials(5, 1) = 0;
monomials(5, 2) = order;
monomials(6, 0) = order+2;
monomials(6, 1) = order+2;
monomials(6, 2) = order;
monomials(7, 0) = 0;
monomials(7, 1) = order+2;
monomials(7, 2) = order;
int index = 8;
static const int bottom_edges[4][2] = {
{0, 1},
{1, 2},
{2, 3},
{3, 0}
};
// bottom & top "edges"
for (int iedge = 0; iedge < 4; ++iedge) {
int i0 = bottom_edges[iedge][0];
int i1 = bottom_edges[iedge][1];
int u_1 = (monomials(i1,0)-monomials(i0,0)) / (order + 2);
int u_2 = (monomials(i1,1)-monomials(i0,1)) / (order + 2);
for (int i = 1; i < order + 2; ++i, ++index) {
monomials(index, 0) = monomials(i0, 0) + i * u_1;
monomials(index, 1) = monomials(i0, 1) + i * u_2;
monomials(index, 2) = 0;
}
for (int i = 1; i < order + 2; ++i, ++index) {
monomials(index, 0) = monomials(i0, 0) + i * u_1;
monomials(index, 1) = monomials(i0, 1) + i * u_2;
monomials(index, 2) = order;
}
}
// bottom & top "face"
fullMatrix<double> uv = gmshGenerateMonomialsQuadrangle(order);
uv.add(1);
for (int i = 0; i < uv.size1(); ++i, ++index) {
monomials(index, 0) = uv(i, 0);
monomials(index, 1) = uv(i, 1);
monomials(index, 2) = 0;
}
for (int i = 0; i < uv.size1(); ++i, ++index) {
monomials(index, 0) = uv(i, 0);
monomials(index, 1) = uv(i, 1);
monomials(index, 2) = order;
}
// other monomials
uv = gmshGenerateMonomialsQuadrangle(order + 2);
for (int k = 1; k < order; ++k) {
for (int i = 0; i < uv.size1(); ++i, ++index) {
monomials(index, 0) = uv(i, 0);
monomials(index, 1) = uv(i, 1);
monomials(index, 2) = k;
}
}
return monomials;
}
