void SurfaceBasis<EvalT, Traits>::
computeCurrentBaseVectors(const SFC & midplaneCoords,
PHX::MDField<ScalarT, Cell, QuadPoint, Dim, Dim> basis)
{
for (int cell(0); cell < midplaneCoords.dimension(0); ++cell) {
// get the midplane coordinates
std::vector<Intrepid::Vector<ScalarT> > midplaneNodes(numPlaneNodes);
for (std::size_t node(0); node < numPlaneNodes; ++node)
midplaneNodes[node] = Intrepid::Vector<ScalarT>(3, &midplaneCoords(cell, node, 0));
Intrepid::Vector<ScalarT> g_0(0, 0, 0), g_1(0, 0, 0), g_2(0, 0, 0);
//compute the base vectors
for (std::size_t pt(0); pt < numQPs; ++pt) {
g_0.clear();
g_1.clear();
g_2.clear();
for (std::size_t node(0); node < numPlaneNodes; ++node) {
g_0 += refGrads(node, pt, 0) * midplaneNodes[node];
g_1 += refGrads(node, pt, 1) * midplaneNodes[node];
}
g_2 = cross(g_0, g_1) / norm(cross(g_0, g_1));
basis(cell, pt, 0, 0) = g_0(0);
basis(cell, pt, 0, 1) = g_0(1);
basis(cell, pt, 0, 2) = g_0(2);
basis(cell, pt, 1, 0) = g_1(0);
basis(cell, pt, 1, 1) = g_1(1);
basis(cell, pt, 1, 2) = g_1(2);
basis(cell, pt, 2, 0) = g_2(0);
basis(cell, pt, 2, 1) = g_2(1);
basis(cell, pt, 2, 2) = g_2(2);
}
}
}
void SurfaceBasis<EvalT, Traits>::computeDualBaseVectors(
const MFC & midplaneCoords,
const PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim, Dim> basis,
PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim> normal,
PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim, Dim> dualBasis)
{
std::size_t worksetSize = midplaneCoords.dimension(0);
Intrepid::Vector<MeshScalarT> g_0(0, 0, 0), g_1(0, 0, 0), g_2(0, 0, 0), g0(0, 0, 0),
g1(0, 0, 0), g2(0, 0, 0);
for (std::size_t cell(0); cell < worksetSize; ++cell) {
for (std::size_t pt(0); pt < numQPs; ++pt) {
g_0 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 0, 0));
g_1 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 1, 0));
g_2 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 2, 0));
normal(cell, pt, 0) = g_2(0);
normal(cell, pt, 1) = g_2(1);
normal(cell, pt, 2) = g_2(2);
g0 = cross(g_1, g_2) / dot(g_0, cross(g_1, g_2));
g1 = cross(g_0, g_2) / dot(g_1, cross(g_0, g_2));
g2 = cross(g_0, g_1) / dot(g_2, cross(g_0, g_1));
dualBasis(cell, pt, 0, 0) = g0(0);
dualBasis(cell, pt, 0, 1) = g0(1);
dualBasis(cell, pt, 0, 2) = g0(2);
dualBasis(cell, pt, 1, 0) = g1(0);
dualBasis(cell, pt, 1, 1) = g1(1);
dualBasis(cell, pt, 1, 2) = g1(2);
dualBasis(cell, pt, 2, 0) = g2(0);
dualBasis(cell, pt, 2, 1) = g2(1);
dualBasis(cell, pt, 2, 2) = g2(2);
}
}
}
void SurfaceVectorGradient<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t pt=0; pt < numQPs; ++pt) {
Intrepid::Vector<ScalarT> g_0(3, ¤tBasis(cell, pt, 0, 0));
Intrepid::Vector<ScalarT> g_1(3, ¤tBasis(cell, pt, 1, 0));
Intrepid::Vector<ScalarT> g_2(3, ¤tBasis(cell, pt, 2, 0));
Intrepid::Vector<ScalarT> G_2(3, &refNormal(cell, pt, 0));
Intrepid::Vector<ScalarT> d(3, &jump(cell, pt, 0));
Intrepid::Vector<ScalarT> G0(3, &refDualBasis(cell, pt, 0, 0));
Intrepid::Vector<ScalarT> G1(3, &refDualBasis(cell, pt, 1, 0));
Intrepid::Vector<ScalarT> G2(3, &refDualBasis(cell, pt, 2, 0));
Intrepid::Tensor<ScalarT>
Fpar(Intrepid::bun(g_0, G0) +
Intrepid::bun(g_1, G1) +
Intrepid::bun(g_2, G2));
// for Jay: bun()
Intrepid::Tensor<ScalarT> Fper((1 / thickness) * Intrepid::bun(d, G_2));
Intrepid::Tensor<ScalarT> F = Fpar + Fper;
defGrad(cell, pt, 0, 0) = F(0, 0);
defGrad(cell, pt, 0, 1) = F(0, 1);
defGrad(cell, pt, 0, 2) = F(0, 2);
defGrad(cell, pt, 1, 0) = F(1, 0);
defGrad(cell, pt, 1, 1) = F(1, 1);
defGrad(cell, pt, 1, 2) = F(1, 2);
defGrad(cell, pt, 2, 0) = F(2, 0);
defGrad(cell, pt, 2, 1) = F(2, 1);
defGrad(cell, pt, 2, 2) = F(2, 2);
J(cell,pt) = Intrepid::det(F);
}
}
if (weightedAverage)
{
ScalarT Jbar, wJbar, vol;
for (std::size_t cell=0; cell < workset.numCells; ++cell)
{
Jbar = 0.0;
vol = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp)
{
Jbar += weights(cell,qp) * std::log( J(cell,qp) );
vol += weights(cell,qp);
}
Jbar /= vol;
// Jbar = std::exp(Jbar);
for (std::size_t qp=0; qp < numQPs; ++qp)
{
for (std::size_t i=0; i < numDims; ++i)
{
for (std::size_t j=0; j < numDims; ++j)
{
wJbar = std::exp( (1-alpha) * Jbar + alpha * std::log( J(cell,qp) ) );
defGrad(cell,qp,i,j) *= std::pow( wJbar / J(cell,qp) ,1./3. );
}
}
J(cell,qp) = wJbar;
}
}
}
}
