Skip to content

Commit

Permalink
Remove unnecessary internal tags in intra-collisions
Browse files Browse the repository at this point in the history 
See merge request gysela-developpers/gyselalibxx!522

--------------------------------------------
  • Loading branch information
@EmilyBourne
EmilyBourne committed Jun 18, 2024
1 parent c679ce0 commit 9905962
Show file tree
Hide file tree
Showing 4 changed files with 63 additions and 123 deletions.
76 changes: 35 additions & 41 deletions src/geometryXVx/rhs/collisions_intra.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,12 +13,11 @@ CollisionsIntra::CollisionsIntra(IDomainSpXVx const& mesh, double nustar0)
, m_fthresh(1.e-30)
, m_nustar_profile_alloc(ddc::select<IDimSp, IDimX>(mesh))
, m_gridvx_ghosted(
ddc::DiscreteElement<ghosted_vx_point_sampling>(0),
ddc::DiscreteVector<ghosted_vx_point_sampling>(ddc::select<IDimVx>(mesh).size() + 2))
ddc::DiscreteElement<GhostedVx>(0),
ddc::DiscreteVector<GhostedVx>(ddc::select<IDimVx>(mesh).size() + 2))
, m_gridvx_ghosted_staggered(
ddc::DiscreteElement<ghosted_vx_staggered_point_sampling>(0),
ddc::DiscreteVector<ghosted_vx_staggered_point_sampling>(
ddc::select<IDimVx>(mesh).size() + 1))
ddc::DiscreteElement<GhostedVxStaggered>(0),
ddc::DiscreteVector<GhostedVxStaggered>(ddc::select<IDimVx>(mesh).size() + 1))
, m_mesh_ghosted(ddc::select<IDimSp>(mesh), ddc::select<IDimX>(mesh), m_gridvx_ghosted)
, m_mesh_ghosted_staggered(
ddc::select<IDimSp>(mesh),
Expand All @@ -34,68 +33,64 @@ CollisionsIntra::CollisionsIntra(IDomainSpXVx const& mesh, double nustar0)
throw std::invalid_argument("Collision operator should not be used with nustar0=0.");
}

double const vx0 = ddc::coordinate(ddc::select<IDimVx>(mesh).front());
double const vx1 = ddc::coordinate(ddc::select<IDimVx>(mesh).front() + 1);
double const vxN = ddc::coordinate(ddc::select<IDimVx>(mesh).back());
double const vxNm1 = ddc::coordinate(ddc::select<IDimVx>(mesh).back() - 1);
CoordVx const vx0 = ddc::coordinate(ddc::select<IDimVx>(mesh).front());
CoordVx const vx1 = ddc::coordinate(ddc::select<IDimVx>(mesh).front() + 1);
CoordVx const vxN = ddc::coordinate(ddc::select<IDimVx>(mesh).back());
CoordVx const vxNm1 = ddc::coordinate(ddc::select<IDimVx>(mesh).back() - 1);
int const ncells(ddc::select<IDimVx>(mesh).size() - 1);
if constexpr (uniform_edge_v) {
double const step(ddc::step<IDimVx>());
ddc::init_discrete_space<ghosted_vx_point_sampling>(
ghosted_vx_point_sampling::
init(ddc::Coordinate<GhostedVx>(vx0 - step),
ddc::Coordinate<GhostedVx>(vxN + step),
ddc::DiscreteVector<ghosted_vx_point_sampling>(ncells + 3)));
ddc::init_discrete_space<GhostedVx>(
GhostedVx::
init(vx0 - step, vxN + step, ddc::DiscreteVector<GhostedVx>(ncells + 3)));
} else {
int const npoints(ncells + 3);
std::vector<ddc::Coordinate<GhostedVx>> breaks(npoints);
breaks[0] = ddc::Coordinate<GhostedVx>(vx0 - (vx1 - vx0));
breaks[npoints - 1] = ddc::Coordinate<GhostedVx>(vxN + (vxN - vxNm1));
std::vector<CoordVx> breaks(npoints);
breaks[0] = vx0 - (vx1 - vx0);
breaks[npoints - 1] = vxN + (vxN - vxNm1);
ddc::for_each(ddc::select<IDimVx>(mesh), [&](IndexVx const ivx) {
breaks[ghosted_from_index(ivx).uid()] = ghosted_from_coord(ddc::coordinate(ivx));
breaks[ghosted_from_index(ivx).uid()] = ddc::coordinate(ivx);
});
ddc::init_discrete_space<ghosted_vx_point_sampling>(breaks);
ddc::init_discrete_space<GhostedVx>(breaks);
}

if constexpr (uniform_edge_v) {
double const step(ddc::step<IDimVx>());
ddc::init_discrete_space<ghosted_vx_staggered_point_sampling>(
ghosted_vx_staggered_point_sampling::
init(ddc::Coordinate<GhostedVxStaggered>(vx0 - step / 2),
ddc::Coordinate<GhostedVxStaggered>(vxN + step / 2),
ddc::DiscreteVector<ghosted_vx_staggered_point_sampling>(ncells + 2)));
ddc::init_discrete_space<GhostedVxStaggered>(
GhostedVxStaggered::
init(vx0 - step / 2,
vxN + step / 2,
ddc::DiscreteVector<GhostedVxStaggered>(ncells + 2)));
} else {
int const npoints(ncells + 2);
std::vector<ddc::Coordinate<GhostedVxStaggered>> breaks(npoints);
breaks[0] = ddc::Coordinate<GhostedVxStaggered>(vx0 - (vx1 - vx0) / 2.);
breaks[npoints - 1] = ddc::Coordinate<GhostedVxStaggered>(vxN + (vxN - vxNm1) / 2.);
std::vector<CoordVx> breaks(npoints);
breaks[0] = vx0 - (vx1 - vx0) / 2.;
breaks[npoints - 1] = vxN + (vxN - vxNm1) / 2.;
IDomainVx const gridvx_less(ddc::select<IDimVx>(mesh).remove_last(IVectVx(1)));
ddc::for_each(gridvx_less, [&](IndexVx const ivx) {
breaks[ivx.uid() + 1] = CollisionsIntra::ghosted_staggered_from_coord(
CoordVx((ddc::coordinate(ivx) + ddc::coordinate(ivx + 1)) / 2.));
breaks[ivx.uid() + 1] = CoordVx((ddc::coordinate(ivx) + ddc::coordinate(ivx + 1)) / 2.);
});
ddc::init_discrete_space<ghosted_vx_staggered_point_sampling>(breaks);
ddc::init_discrete_space<GhostedVxStaggered>(breaks);
}

m_nustar_profile = m_nustar_profile_alloc.span_view();
compute_nustar_profile(m_nustar_profile, m_nustar0);
ddc::expose_to_pdi("collintra_nustar0", m_nustar0);
}

ddc::DiscreteDomain<CollisionsIntra::ghosted_vx_point_sampling> const& CollisionsIntra::
get_gridvx_ghosted() const
ddc::DiscreteDomain<CollisionsIntra::GhostedVx> const& CollisionsIntra::get_gridvx_ghosted() const
{
return m_gridvx_ghosted;
}

ddc::DiscreteDomain<CollisionsIntra::ghosted_vx_staggered_point_sampling> const& CollisionsIntra::
ddc::DiscreteDomain<CollisionsIntra::GhostedVxStaggered> const& CollisionsIntra::
get_gridvx_ghosted_staggered() const
{
return m_gridvx_ghosted_staggered;
}

ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::ghosted_vx_point_sampling> const&
CollisionsIntra::get_mesh_ghosted() const
ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::GhostedVx> const& CollisionsIntra::
get_mesh_ghosted() const
{
return m_mesh_ghosted;
}
Expand Down Expand Up @@ -272,29 +267,28 @@ DSpanSpXVx CollisionsIntra::operator()(DSpanSpXVx allfdistribu, double dt) const
// diffusion coefficient
device_t<ddc::Chunk<double, IDomainSpXVx_ghosted>> Dcoll_alloc(m_mesh_ghosted);
auto Dcoll = Dcoll_alloc.span_view();
compute_Dcoll<ghosted_vx_point_sampling>(Dcoll, collfreq, density, temperature);
compute_Dcoll<GhostedVx>(Dcoll, collfreq, density, temperature);

device_t<ddc::Chunk<double, IDomainSpXVx_ghosted>> dvDcoll_alloc(m_mesh_ghosted);
auto dvDcoll = dvDcoll_alloc.span_view();
compute_dvDcoll<ghosted_vx_point_sampling>(dvDcoll, collfreq, density, temperature);
compute_dvDcoll<GhostedVx>(dvDcoll, collfreq, density, temperature);

device_t<ddc::Chunk<double, IDomainSpXVx_ghosted_staggered>> Dcoll_staggered_alloc(
m_mesh_ghosted_staggered);
auto Dcoll_staggered = Dcoll_staggered_alloc.span_view();
compute_Dcoll<
ghosted_vx_staggered_point_sampling>(Dcoll_staggered, collfreq, density, temperature);
compute_Dcoll<GhostedVxStaggered>(Dcoll_staggered, collfreq, density, temperature);

// kernel maxwellian fluid moments
DFieldSpX Vcoll_alloc(grid_sp_x);
DFieldSpX Tcoll_alloc(grid_sp_x);
auto Vcoll = Vcoll_alloc.span_view();
auto Tcoll = Tcoll_alloc.span_view();
compute_Vcoll_Tcoll<ghosted_vx_point_sampling>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);
compute_Vcoll_Tcoll<GhostedVx>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);

// convection coefficient Nucoll
device_t<ddc::Chunk<double, IDomainSpXVx_ghosted>> Nucoll_alloc(m_mesh_ghosted);
auto Nucoll = Nucoll_alloc.span_view();
compute_Nucoll<ghosted_vx_point_sampling>(Nucoll, Dcoll, Vcoll, Tcoll);
compute_Nucoll<GhostedVx>(Nucoll, Dcoll, Vcoll, Tcoll);

// matrix coefficients
DFieldSpXVx AA_alloc(allfdistribu.domain());
Expand Down
74 changes: 17 additions & 57 deletions src/geometryXVx/rhs/collisions_intra.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,103 +37,64 @@
*/
class CollisionsIntra : public IRightHandSide
{
public:
/**
* @brief A struct representing a tag to construct a mesh with ghosted points.
*/
struct GhostedVx
{
};

/**
* @brief A struct representing a tag to construct a mesh with ghosted and staggered points.
*/
struct GhostedVxStaggered
{
};

private:
static constexpr bool uniform_edge_v = ddc::is_uniform_sampling_v<IDimVx>;

public:
/**
* A conditional type representing either a uniform or a non-uniform ghosted vx mesh.
*/
struct ghosted_vx_point_sampling
struct GhostedVx
: std::conditional_t<
uniform_edge_v,
ddc::UniformPointSampling<GhostedVx>,
ddc::NonUniformPointSampling<GhostedVx>>
ddc::UniformPointSampling<RDimVx>,
ddc::NonUniformPointSampling<RDimVx>>
{
};

/**
* A conditional type representing either a uniform or a non-uniform ghosted staggered vx mesh.
*/
struct ghosted_vx_staggered_point_sampling
struct GhostedVxStaggered
: std::conditional_t<
uniform_edge_v,
ddc::UniformPointSampling<GhostedVxStaggered>,
ddc::NonUniformPointSampling<GhostedVxStaggered>>
ddc::UniformPointSampling<RDimVx>,
ddc::NonUniformPointSampling<RDimVx>>
{
};

/**
* A type representing a mesh for species, space and ghosted vx mesh.
*/
using IDomainSpXVx_ghosted = ddc::DiscreteDomain<IDimSp, IDimX, ghosted_vx_point_sampling>;
using IDomainSpXVx_ghosted = ddc::DiscreteDomain<IDimSp, IDimX, GhostedVx>;

/**
* A type representing a mesh for species, space and ghosted staggered vx mesh.
*/
using IDomainSpXVx_ghosted_staggered
= ddc::DiscreteDomain<IDimSp, IDimX, ghosted_vx_staggered_point_sampling>;
using IDomainSpXVx_ghosted_staggered = ddc::DiscreteDomain<IDimSp, IDimX, GhostedVxStaggered>;

/**
* A type representing a ghosted vx index.
*/
using IndexVx_ghosted = ddc::DiscreteElement<ghosted_vx_point_sampling>;
using IndexVx_ghosted = ddc::DiscreteElement<GhostedVx>;

/**
* A type representing a ghosted staggered vx index.
*/
using IndexVx_ghosted_staggered = ddc::DiscreteElement<ghosted_vx_staggered_point_sampling>;
using IndexVx_ghosted_staggered = ddc::DiscreteElement<GhostedVxStaggered>;

/**
* A type representing a species, space and ghosted vx index.
*/
using IndexSpXVx_ghosted = ddc::DiscreteElement<IDimSp, IDimX, ghosted_vx_point_sampling>;
using IndexSpXVx_ghosted = ddc::DiscreteElement<IDimSp, IDimX, GhostedVx>;

/**
* A type representing a species, space and ghosted staggered vx index.
*/
using IndexSpXVx_ghosted_staggered
= ddc::DiscreteElement<IDimSp, IDimX, ghosted_vx_staggered_point_sampling>;
using IndexSpXVx_ghosted_staggered = ddc::DiscreteElement<IDimSp, IDimX, GhostedVxStaggered>;


private:
static ddc::Coordinate<GhostedVx> ghosted_from_coord(ddc::Coordinate<RDimVx> const& coord)
{
return ddc::Coordinate<GhostedVx>(ddc::get<RDimVx>(coord));
}
static ddc::Coordinate<RDimVx> coord_from_ghosted(ddc::Coordinate<GhostedVx> const& coord)
{
return ddc::Coordinate<RDimVx>(ddc::get<GhostedVx>(coord));
}
static ddc::Coordinate<GhostedVxStaggered> ghosted_staggered_from_coord(
ddc::Coordinate<RDimVx> const& coord)
{
return ddc::Coordinate<GhostedVxStaggered>(ddc::get<RDimVx>(coord));
}
static ddc::Coordinate<RDimVx> coord_from_ghosted_staggered(
ddc::Coordinate<GhostedVxStaggered> const& coord)
{
return ddc::Coordinate<RDimVx>(ddc::get<GhostedVxStaggered>(coord));
}
static IndexVx index_from_ghosted(ddc::DiscreteElement<GhostedVx> const& index_ghosted)
{
return IndexVx(index_ghosted.uid() - 1);
}
KOKKOS_FUNCTION static IndexVx_ghosted ghosted_from_index(IndexVx const& index)
{
return IndexVx_ghosted(index.uid() + 1);
Expand All @@ -150,8 +111,8 @@ class CollisionsIntra : public IRightHandSide
DFieldSpX m_nustar_profile_alloc;
DSpanSpX m_nustar_profile;

ddc::DiscreteDomain<ghosted_vx_point_sampling> m_gridvx_ghosted;
ddc::DiscreteDomain<ghosted_vx_staggered_point_sampling> m_gridvx_ghosted_staggered;
ddc::DiscreteDomain<GhostedVx> m_gridvx_ghosted;
ddc::DiscreteDomain<GhostedVxStaggered> m_gridvx_ghosted_staggered;

IDomainSpXVx_ghosted m_mesh_ghosted;
IDomainSpXVx_ghosted_staggered m_mesh_ghosted_staggered;
Expand Down Expand Up @@ -194,22 +155,21 @@ class CollisionsIntra : public IRightHandSide
*
* @return The ghosted vx mesh.
*/
ddc::DiscreteDomain<ghosted_vx_point_sampling> const& get_gridvx_ghosted() const;
ddc::DiscreteDomain<GhostedVx> const& get_gridvx_ghosted() const;

/**
* @brief Get the ghosted and staggered vx mesh used for computing finite differences centered derivatives.
*
* @return The ghosted and staggered vx mesh.
*/
ddc::DiscreteDomain<ghosted_vx_staggered_point_sampling> const& get_gridvx_ghosted_staggered()
const;
ddc::DiscreteDomain<GhostedVxStaggered> const& get_gridvx_ghosted_staggered() const;

/**
* @brief Get a mesh containing the species, spatial and the ghosted vx mesh.
*
* @return The species, spatial, and ghosted vx mesh.
*/
ddc::DiscreteDomain<IDimSp, IDimX, ghosted_vx_point_sampling> const& get_mesh_ghosted() const;
ddc::DiscreteDomain<IDimSp, IDimX, GhostedVx> const& get_mesh_ghosted() const;

/**
* @brief Compute the right-hand-side of the collision operator linear system.
Expand Down
6 changes: 3 additions & 3 deletions tests/geometryXVx/collisions_intra_gridvx.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -68,10 +68,10 @@ TEST(CollisionsIntraGridvx, CollisionsIntraGridvx)
// collision operator
double const nustar0(1.);
CollisionsIntra collisions(mesh, nustar0);
ddc::DiscreteDomain<CollisionsIntra::ghosted_vx_point_sampling> gridvx_ghosted
ddc::DiscreteDomain<CollisionsIntra::GhostedVx> gridvx_ghosted
= collisions.get_gridvx_ghosted();
ddc::DiscreteDomain<CollisionsIntra::ghosted_vx_staggered_point_sampling>
gridvx_ghosted_staggered = collisions.get_gridvx_ghosted_staggered();
ddc::DiscreteDomain<CollisionsIntra::GhostedVxStaggered> gridvx_ghosted_staggered
= collisions.get_gridvx_ghosted_staggered();

double const npoints(gridvx.size());
std::vector<double> gridvx_ghosted_pred(npoints + 2);
Expand Down
30 changes: 8 additions & 22 deletions tests/geometryXVx/collisions_intra_maxwellian.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -161,31 +161,22 @@ TEST(CollisionsIntraMaxwellian, CollisionsIntraMaxwellian)
});

// diffusion coefficient
device_t<ddc::Chunk<
double,
ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::ghosted_vx_point_sampling>>>
device_t<ddc::Chunk<double, ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::GhostedVx>>>
Dcoll_f(collisions.get_mesh_ghosted());
auto Dcoll = Dcoll_f.span_view();
compute_Dcoll<
CollisionsIntra::
ghosted_vx_point_sampling>(Dcoll, collfreq, density_init, temperature_init);
compute_Dcoll<CollisionsIntra::GhostedVx>(Dcoll, collfreq, density_init, temperature_init);

device_t<ddc::Chunk<
double,
ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::ghosted_vx_point_sampling>>>
device_t<ddc::Chunk<double, ddc::DiscreteDomain<IDimSp, IDimX, CollisionsIntra::GhostedVx>>>
dvDcoll_f(collisions.get_mesh_ghosted());
auto dvDcoll = dvDcoll_f.span_view();
compute_dvDcoll<
CollisionsIntra::
ghosted_vx_point_sampling>(dvDcoll, collfreq, density_init, temperature_init);
compute_dvDcoll<CollisionsIntra::GhostedVx>(dvDcoll, collfreq, density_init, temperature_init);

// kernel maxwellian fluid moments
DFieldSpX Vcoll_f(ddc::get_domain<IDimSp, IDimX>(allfdistribu_host));
DFieldSpX Tcoll_f(ddc::get_domain<IDimSp, IDimX>(allfdistribu_host));
auto Vcoll = Vcoll_f.span_view();
auto Tcoll = Tcoll_f.span_view();
compute_Vcoll_Tcoll<
CollisionsIntra::ghosted_vx_point_sampling>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);
compute_Vcoll_Tcoll<CollisionsIntra::GhostedVx>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);

host_t<DFieldSpX> Vcoll_host(ddc::get_domain<IDimSp, IDimX>(allfdistribu_host));
host_t<DFieldSpX> Tcoll_host(ddc::get_domain<IDimSp, IDimX>(allfdistribu_host));
Expand Down Expand Up @@ -302,16 +293,11 @@ TEST(CollisionsIntraMaxwellian, CollisionsIntraMaxwellian)
// Vcoll and Tcoll calculation
compute_collfreq(collfreq, nustar_profile, density_init, temperature_init);

compute_Dcoll<
CollisionsIntra::
ghosted_vx_point_sampling>(Dcoll, collfreq, density_init, temperature_init);
compute_Dcoll<CollisionsIntra::GhostedVx>(Dcoll, collfreq, density_init, temperature_init);

compute_dvDcoll<
CollisionsIntra::
ghosted_vx_point_sampling>(dvDcoll, collfreq, density_init, temperature_init);
compute_dvDcoll<CollisionsIntra::GhostedVx>(dvDcoll, collfreq, density_init, temperature_init);

compute_Vcoll_Tcoll<
CollisionsIntra::ghosted_vx_point_sampling>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);
compute_Vcoll_Tcoll<CollisionsIntra::GhostedVx>(Vcoll, Tcoll, allfdistribu, Dcoll, dvDcoll);

moments(density_res.span_view(), allfdistribu_host.span_cview(), FluidMoments::s_density);
moments(mean_velocity_res.span_view(),
Expand Down

0 comments on commit 9905962

Please sign in to comment.