callback.hpp

Go to the documentation of this file.

 
#ifndef CALLBACK_HPP
#define CALLBACK_HPP
 
#include <cstddef>
#include <string>
#include <memory>
#include <type_traits>
 
#include "H5Cpp.h"
 
#include "fields.hpp"
#include "geom_utils.hpp"
 
template<typename AFields>
struct Callback
{
    template<typename T>
    class BaseProperties
    {// {{{
        // declare as char so we can advance byte-wise
        // (char is guaranteed to be one byte wide)
        char *data[T::Nfields];
 
        template<typename Field>
        static constexpr size_t get_field_idx ();
 
    public :
        // optional offset initializes at offset particles inside the data_in_memory pointers
        BaseProperties (void *data_in_memory[T::Nfields], size_t offset=0UL);
 
        // advances the internal pointers by the respective strides
        // User should not call this!
        void advance ();
 
        // retrieves the internal pointers
        // User should not need to call this
        void *operator[] (size_t idx) const;
 
        auto coord () const;
        
        template<typename Field>
        auto get () const;
    };// }}}
 
    class GrpProperties : public BaseProperties<typename AFields::GroupFields>
    {
        using BaseProperties<typename AFields::GroupFields>::BaseProperties;
 
    public :
        size_t chunk_idx;
        GrpProperties (size_t chunk_idx_, void **data_in_memory, size_t offset=0UL);
    };
 
    struct PrtProperties : public BaseProperties<typename AFields::ParticleFields>
    {
        coord_t Bsize;
 
        PrtProperties (coord_t Bsize_, void **data_in_memory, size_t offset=0UL);
 
        // get around the name hiding issue
        using BaseProperties<typename AFields::ParticleFields>::coord;
 
        std::array<coord_t, 3> coord (const coord_t *grp_coord) const;
    };
 
    virtual bool grp_chunk (size_t chunk_idx, std::string &fname) const = 0;
 
    virtual bool prt_chunk (size_t chunk_idx, std::string &fname) const = 0;
 
    virtual std::string grp_name () const = 0;
 
    virtual std::string prt_name () const = 0;
 
    virtual void read_grp_meta_init (std::shared_ptr<H5::H5File> fptr) { return; }
 
    virtual void read_prt_meta_init (std::shared_ptr<H5::H5File> fptr) { return; }
 
    virtual void read_grp_meta (size_t chunk_idx, std::shared_ptr<H5::H5File> fptr,
                                size_t &Ngroups) const = 0;
 
    virtual void read_prt_meta (size_t chunk_idx, std::shared_ptr<H5::H5File> fptr,
                                coord_t &Bsize, size_t &Nparts) const = 0;
 
    virtual bool grp_select (const GrpProperties &grp) const { return true; }
 
    virtual void grp_action (const GrpProperties &grp) = 0;
 
    virtual coord_t grp_radius (const GrpProperties &grp) const = 0;
 
    virtual void prt_action (size_t grp_idx, const GrpProperties &grp,
                             const PrtProperties &prt, coord_t Rsq) = 0;
 
    virtual coord_t prt_coord_rescale ( ) const { return 1.0; }
 
    virtual void prt_modify (PrtProperties &prt) { return; }
};
 
 
// --- Implementation of the BaseProperties struct ---
 
template<typename AFields>
template<typename T>
Callback<AFields>::BaseProperties<T>::BaseProperties (void *data_in_memory[T::Nfields], size_t offset)
{
    for (size_t ii=0; ii != T::Nfields; ++ii)
        data[ii] = (char *)(data_in_memory[ii]) + offset * T::strides_fcoord[ii];
}
 
template<typename AFields>
template<typename T>
inline void
Callback<AFields>::BaseProperties<T>::advance ()
{
    for (size_t ii=0; ii != T::Nfields; ++ii)
        data[ii] += T::strides_fcoord[ii];
}
 
template<typename AFields>
template<typename T>
inline void *
Callback<AFields>::BaseProperties<T>::operator[] (size_t idx) const
{
    return data[idx];
}
 
template<typename AFields>
template<typename T>
inline auto
Callback<AFields>::BaseProperties<T>::coord () const
{
    return (coord_t *)data[0];
}
 
template<typename AFields>
template<typename T>
template<typename Field>
constexpr size_t
Callback<AFields>::BaseProperties<T>::get_field_idx ()
{
    static_assert(T::field_type == Field::type);
 
    if constexpr (T::field_type == FieldTypes::GrpFld)
        return AFields::GroupFields::template idx<Field>;
    else
        return AFields::ParticleFields::template idx<Field>;
}
 
template<typename AFields>
template<typename T>
template<typename Field>
inline auto
Callback<AFields>::BaseProperties<T>::get () const
{
    constexpr size_t idx = get_field_idx<Field> ();
 
    if constexpr (Field::dim == 1)
        return (typename Field::value_type) *(typename Field::value_type *)data[idx];
    else
        if constexpr (Field::coord)
        // need to use the global coord_t that this field has been converted to
            return (coord_t *)data[idx];
        else
            return (typename Field::value_type *)data[idx];
}
 
template<typename AFields>
Callback<AFields>::GrpProperties::GrpProperties (size_t chunk_idx_, void **data_in_memory, size_t offset) :
    Callback<AFields>::template BaseProperties<typename AFields::GroupFields> { data_in_memory, offset },
    chunk_idx { chunk_idx_ }
{ }
 
template<typename AFields>
Callback<AFields>::PrtProperties::PrtProperties (coord_t Bsize_, void **data_in_memory, size_t offset) :
    Callback<AFields>::template BaseProperties<typename AFields::ParticleFields> { data_in_memory, offset },
    Bsize { Bsize_ }
{ }
 
template<typename AFields>
inline std::array<coord_t, 3>
Callback<AFields>::PrtProperties::coord (const coord_t *grp_coord) const
{
    std::array<coord_t, 3> out;
 
    coord_t * prt_coord = Callback<AFields>::template BaseProperties<typename AFields::ParticleFields>::coord();
 
    for (size_t ii=0; ii != 3; ++ii)
        out[ii] = grp_prt_detail::GeomUtils::periodic_dist(grp_coord[ii], prt_coord[ii], Bsize);
 
    return out;
}
 
#endif // CALLBACK_HPP