CellIpData.h

Go to the documentation of this file.

#pragma once

#include "nuto/mechanics/dofs/DofContainer.h"
#include "nuto/mechanics/cell/CellData.h"
#include "nuto/mechanics/cell/Jacobian.h"
#include "nuto/mechanics/cell/DifferentialOperators.h"
#include "nuto/mechanics/cell/CellIds.h"

namespace NuTo
{

class CellIpData
{
public:
    CellIpData(const CellData& cellData, NuTo::Jacobian jacobian, NaturalCoords ipCoords, int ipId)
        : mCellData(cellData)
        , mJacobian(std::move(jacobian))
        , mIPCoords(std::move(ipCoords))
        , mIpId(ipId)
    {
    }

    Eigen::VectorXd GlobalCoordinates() const
    {
        return Interpolate(mCellData.Elements().CoordinateElement(), mIPCoords);
    }

    CellIds Ids() const
    {
        return {mCellData.GetCellId(), mIpId};
    }

    Eigen::VectorXd Value(DofType dofType, int instance = 0) const
    {
        return N(dofType) * NodeValueVector(dofType, instance);
    }

    const NuTo::Jacobian& GetJacobian() const
    {
        return mJacobian;
    }

    double Value(ScalarDofType dofType, int instance = 0) const
    {
        return Value(DofType(dofType), instance)[0];
    }

    Eigen::VectorXd Apply(DofType dofType, const Nabla::Interface& b, int instance = 0) const
    {
        return B(dofType, b) * NodeValueVector(dofType, instance);
    }

    const Eigen::MatrixXd& N(DofType dofType) const
    {
        Eigen::MatrixXd& N = mNs[dofType];
        if (N.size() == 0) // simplest memoization using a mutable mNs to keep it const
            N = mCellData.Elements().DofElement(dofType).GetNMatrix(mIPCoords);
        return N;
    }

    const Eigen::MatrixXd& B(DofType dofType, const Nabla::Interface& b) const
    {
        Eigen::MatrixXd& B = mBs[dofType];
        if (B.size() == 0) // simplest memoization using a mutable mBs to keep it const
            B = b(CalculateDerivativeShapeFunctionsGlobal(dofType));
        return B;
    }

    const Eigen::VectorXd& NodeValueVector(DofType dofType, int instance = 0) const
    {
        return mCellData.GetNodeValues(dofType, instance);
    }

private:
    Eigen::MatrixXd CalculateDerivativeShapeFunctionsGlobal(DofType dofType) const
    {
        Eigen::MatrixXd dShapeNatural =
                mCellData.Elements().DofElement(dofType).GetDerivativeShapeFunctions(mIPCoords);
        return mJacobian.TransformDerivativeShapeFunctions(dShapeNatural);
    }

    const CellData& mCellData;
    NuTo::Jacobian mJacobian;
    NaturalCoords mIPCoords;
    int mIpId;

    mutable DofContainer<Eigen::MatrixXd> mBs;
    mutable DofContainer<Eigen::MatrixXd> mNs;
};
} /* NuTo */