MeanField/libmeanfield/impl/integrators/coriolis.cpp

module;
#include <mfem.hpp>

module mean_field;

namespace mean_field::integrators {
    CoriolisIntegrator::CoriolisIntegrator(
        const mapping::DomainMapper &mapper,
        const mfem::GridFunction &displacement,
        const mfem::GridFunction &compactification_coordinate,
        const mfem::Vector &omega
    )
        : m_mapping(mapper, displacement, compactification_coordinate),
          m_omega(omega) {
        m_omega_mat.SetSize(3, 3);
        m_omega_mat       = 0.0;
        m_omega_mat(0, 1) = -m_omega(2);
        m_omega_mat(0, 2) = m_omega(1);
        m_omega_mat(1, 0) = m_omega(2);
        m_omega_mat(1, 2) = -m_omega(0);
        m_omega_mat(2, 0) = -m_omega(1);
        m_omega_mat(2, 1) = m_omega(0);
    }

    void CoriolisIntegrator::AssembleElementVector(
        const mfem::Array<const mfem::FiniteElement *> &el,
        mfem::ElementTransformation &Tr,
        const mfem::Array<const mfem::Vector *> &elfun,
        const mfem::Array<mfem::Vector *> &elvec
    ) {
        m_mapping.InvalidateCache();

        if (utils::is_vacuum(Tr, elvec)) {
            return;
        }

        const mfem::FiniteElement *fe_v   = el[0];
        const mfem::FiniteElement *fe_rho = el[1];

        const int dof_v                   = fe_v->GetDof();
        const int dof_rho                 = fe_rho->GetDof();
        const int dim                     = Tr.GetSpaceDim();

        const mfem::Vector &v_dofs        = *elfun[0];
        const mfem::Vector &rho_dofs      = *elfun[1];

        mfem::Vector &r_v                 = *elvec[0];
        r_v.SetSize(dof_v * dim);
        r_v = 0.0;
        if (elvec[1]) {
            elvec[1]->SetSize(dof_rho);
            *elvec[1] = 0.0;
        }

        mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());

        for (int q = 0; q < ir->GetNPoints(); ++q) {
            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
            Tr.SetIntPoint(&ip);

            auto [J_inv, detJ, weight] = m_mapping.GetQuadratureContext(Tr, ip);

            fe_v->CalcShape(ip, shape_v);
            fe_rho->CalcShape(ip, shape_rho);

            double rho_val = 0.0;
            for (int i = 0; i < dof_rho; ++i)
                rho_val += rho_dofs(i) * shape_rho(i);

            mfem::Vector v_val(dim);
            v_val = 0.0;
            for (int i = 0; i < dof_v; ++i) {
                for (int c = 0; c < dim; ++c)
                    v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
            }

            mfem::Vector F_coriolis(dim);
            m_omega_mat.Mult(v_val, F_coriolis);
            F_coriolis *= 2.0;

            for (int i = 0; i < dof_v; ++i) {
                for (int c = 0; c < dim; ++c) {
                    r_v(i + c * dof_v) += shape_v(i) * rho_val * F_coriolis(c) * weight;
                }
            }
        }
    }

    void CoriolisIntegrator::AssembleElementGrad(
        const mfem::Array<const mfem::FiniteElement *> &el,
        mfem::ElementTransformation &Tr,
        const mfem::Array<const mfem::Vector *> &elfun,
        const mfem::Array2D<mfem::DenseMatrix *> &elmats
    ) {
        m_mapping.InvalidateCache();

        const mfem::FiniteElement *fe_v   = el[0];
        const mfem::FiniteElement *fe_rho = el[1];

        const int dof_v                   = fe_v->GetDof();
        const int dof_rho                 = fe_rho->GetDof();
        const int dim                     = Tr.GetSpaceDim();

        const mfem::Vector &v_dofs        = *elfun[0];
        const mfem::Vector &rho_dofs      = *elfun[1];

        mfem::DenseMatrix *dv_dv          = elmats(0, 0);
        mfem::DenseMatrix *dv_drho        = elmats(0, 1);

        if (dv_dv)
            *dv_dv = 0.0;
        if (dv_drho)
            *dv_drho = 0.0;

        mfem::Vector shape_v(dof_v), shape_rho(dof_rho);
        const mfem::IntegrationRule *ir = &mfem::IntRules.Get(fe_v->GetGeomType(), 2 * fe_v->GetOrder());

        for (int q = 0; q < ir->GetNPoints(); ++q) {
            const mfem::IntegrationPoint &ip = ir->IntPoint(q);
            Tr.SetIntPoint(&ip);

            auto [J_inv, detJ, weight] = m_mapping.GetQuadratureContext(Tr, ip);

            fe_v->CalcShape(ip, shape_v);
            fe_rho->CalcShape(ip, shape_rho);

            double rho_val = 0.0;
            for (int i = 0; i < dof_rho; ++i)
                rho_val += rho_dofs(i) * shape_rho(i);

            mfem::Vector v_val(dim);
            v_val = 0.0;
            for (int i = 0; i < dof_v; ++i) {
                for (int c = 0; c < dim; ++c)
                    v_val(c) += v_dofs(i + c * dof_v) * shape_v(i);
            }

            mfem::Vector F_coriolis(dim);
            m_omega_mat.Mult(v_val, F_coriolis);
            F_coriolis *= 2.0;

            if (dv_dv) {
                for (int i = 0; i < dof_v; ++i) {
                    for (int c = 0; c < dim; ++c) {
                        const int row = i + c * dof_v;
                        for (int j = 0; j < dof_v; ++j) {
                            for (int d = 0; d < dim; ++d) {
                                int col         = j + d * dof_v;
                                double coupling = m_omega_mat(c, d);
                                (*dv_dv)(row, col) += shape_v(i) * shape_v(j) * 2.0 * rho_val * coupling * weight;
                            }
                        }
                    }
                }
            }

            if (dv_drho) {
                for (int i = 0; i < dof_v; ++i) {
                    for (int c = 0; c < dim; ++c) {
                        int row = i + c * dof_v;
                        for (int j = 0; j < dof_rho; ++j) {
                            int col = j;
                            (*dv_drho)(row, col) += shape_v(i) * shape_rho(j) * F_coriolis(c) * weight;
                        }
                    }
                }
            }
        }
    }
} // namespace mean_field::integrators