phase_space_element.h

Go to the documentation of this file.

#ifndef geometry_phase_space_element_h
#define geometry_phase_space_element_h
 
// WARPXM includes
#include "lib/geometry/phase_space_geometry/phase_space_dg_geometry.h"
 
namespace geometry
{
namespace phase_space_element
{
 
// Helper
int getLocalPhaseSpaceNodeIndex(const int l,
                                const int N,
                                const int m,
                                const int i,
                                const int j,
                                const int k);
 
class PhaseSpaceFace
{
public:
    PhaseSpaceFace()
    {
    }
 
    void setup(const int local_face_index)
    {
        _local_face_index = local_face_index;
    }
 
    void setNeighborLocalFaceIndex(const int neighbor_local_face_index)
    {
        _neighbor_local_face_index = neighbor_local_face_index;
    }
    // void setPhaseSpaceFullNormal(const real nx,
    //                          const real ny,
    //                          const real nz,
    //                          const real nvx,
    //                          const real nvy,
    //                          const real nvz)
    // {
    //     _full_real_normal[0] = nx;
    //     _full_real_normal[1] = ny;
    //     _full_real_normal[2] = nz;
    //     _full_real_normal[3] = nvx;
    //     _full_real_normal[4] = nvy;
    //     _full_real_normal[5] = nvz;
 
    //     for (int i = 0; i < 6; i++)
    //     {
    //         _full_isoparametric_normal[i] = _full_real_normal[i];
    //     }
    // }
 
    void setPhaseSpaceNormal(const std::vector<real> normal)
    {
        for (const auto& component : normal)
        {
            _real_normal.push_back(component);
            _isoparametric_normal.push_back(component);
        }
    }
 
    void setPhaseSpaceIsoparametricNormal(const std::vector<real>& iso_normal)
    {
        for (const auto& component : iso_normal)
        {
            _isoparametric_normal.push_back(component);
        }
    }
 
    const real* getRealNormal() const
    {
        return _real_normal.data();
    }
 
    const real* getIsoparametricNormal() const
    {
        return _isoparametric_normal.data();
    }
 
    void setNfp(const int N_fp_phase_space)
    {
        _N_fp_phase_space = N_fp_phase_space;
    }
 
    int getNfp() const
    {
        return _N_fp_phase_space;
    }
 
    void setLocalFaceNodes(const WmBasisArraySet* phase_space_basis_set,
                           const int local_face_index)
    {
        const int* face_nodes = phase_space_basis_set->getFaceNodes(local_face_index);
        for (int i = 0; i < _N_fp_phase_space; i++)
        {
            _local_face_nodes.push_back(face_nodes[i]);
        }
    }
 
    const int* getLocalFaceNodes() const
    {
        return &(_local_face_nodes[0]);
    }
 
    void setNeighborLocalFaceNodes(const WmBasisArraySet* phase_space_basis_set,
                                   const int neighbor_local_face_index)
    {
        // The face nodes should be oriented to that the opposite neighbor nodes line up
        // in the array exactly
        const int* neighbor_face_nodes =
            phase_space_basis_set->getFaceNodes(neighbor_local_face_index);
        for (int i = 0; i < _N_fp_phase_space; i++)
        {
            _neighbor_local_face_nodes.push_back(neighbor_face_nodes[i]);
        }
    }
 
    const int* getNeighborLocalFaceNodes() const
    {
        return &(_neighbor_local_face_nodes[0]);
    }
 
private:
    int _local_face_index;
    int _neighbor_local_face_index;
    // // normals real space [6]
    // std::vector<real> _full_real_normal;
    // // isoparametric space [6]
    // std::vector<real> _full_isoparametric_normal;
    // only number of phase space dimensions of element
    std::vector<real> _real_normal;
    std::vector<real> _isoparametric_normal;
 
    int _N_fp_phase_space;      
    std::vector<int> _local_face_nodes;
    std::vector<int> _neighbor_local_face_nodes;
 
    // _local_face_nodes=[0,1,2];
    // _neighbor_local_face_nodes = [6, 7, 8];
    // getGlobalPhysicalSpaceNode()
    // getOppositGelobalPhysicalSpaceNode()
    // getGlobalPhaseSpaceNodeIndices(physical_element, velocity_space_indexes);
    // getOppositeGlobalPhaseNodeIndices(physical_element, velocity_space_indexes)
    //  {
 
    //  }
};
 
class PhaseSpaceElement
{
public:
    PhaseSpaceElement(const std::shared_ptr<geometry::phase_space::PhaseSpaceDGGeometry>&
                          phase_space_dg_geometry);
    virtual ~PhaseSpaceElement() = default;
 
    virtual void setup();
 
    int getNdPhysicalSpace()
    {
        return _N_d_physical_space;
    }
 
    int getNdVelocitySpace()
    {
        return _N_d_velocity_space;
    }
 
    int getNdPhaseSpace()
    {
        return _N_d_phase_space;
    }
 
    virtual void setNd() = 0;
 
 
    void setSpatialFaceOrientations();
 
    geometry::phase_space_element::PhaseSpaceFace const*
    getFace(const int local_face_index) const
    {
        return _phase_space_faces[local_face_index].get();
    }
 
    int getNeighborGlobalPhysicalSpaceNodeIndexFromSpatialFace(
    const int physical_element_index,
    const int phase_space_element_local_face_index,
    const int phase_space_element_face_node_index) const;
    
    int getNeighborGlobalPhaseSpaceNodeIndexFromSpatialFace(
    const int phase_space_element_face_node_index,
    const int neighbor_global_physical_element_index,
    const int phase_space_neighbor_element_local_face_index,
    const int orientation,
    const int velocity_space_element_indexes[3]) const;
 
    
    virtual void getCommonNormal(const int physical_element_index,
                                 const int phaseSpaceElementFaceIndex,
                                 std::vector<real>& phaseSpaceCommonNormal) const = 0;
 
protected:
    int _N_d_physical_space;
    int _N_d_velocity_space;
    int _N_d_phase_space;
 
    // Phase space geometry
    std::shared_ptr<geometry::phase_space::PhaseSpaceDGGeometry> _phase_space_dg_geometry;
 
    // Vector of pointers to the faces of this element
    std::vector<std::unique_ptr<geometry::phase_space_element::PhaseSpaceFace>>
        _phase_space_faces;
 
    // add orientations for spatial faces
    // This creates the corresponding arrays of the phase space element spatial faces that
    // continue from the base physical elemnt face e.g. if the triangle 3rd order face
    // orientation is 0, 1, 2, then for the corresponding cube face of the duoprism you
    // need to add the rest of the phase space nodes of the cube -> 0, 1, 2, ... the other
    // cube nodes N_orientations (physical space) x Nfp_phase_space (for spatial faces)
    std::vector<int> _spatial_face_orientation;
};
 
} // namespace phase_space_element
} // namespace geometry
 
#endif