CD_GenericParticle.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_GENERICPARTICLE_H
#define CD_GENERICPARTICLE_H
 
// Std includes
#include <string>
#include <typeinfo>
#include <cstdio>
#include <cmath>
#include <array>
#include <cstdint>
 
// Chombo includes
#include <RealVect.H>
 
// Our includes
#include <CD_NamespaceHeader.H>
 
namespace detail {
  template <class T>
  inline void
  pushParticleProperty(uint8_t*& p, const T& a_x)
  {
    static_assert(std::is_trivially_copyable<T>::value,
                  "detail::pushParticleProperty expects trivially-copyable fields");
 
    std::memcpy(p, &a_x, sizeof(T));
 
    p += sizeof(T);
  };
 
  template <class T>
  inline void
  pullParticleProperty(const uint8_t*& p, T& a_x)
  {
    static_assert(std::is_trivially_copyable<T>::value,
                  "detail::pushParticleProperty expects trivially-copyable fields");
 
    std::memcpy(&a_x, p, sizeof(T));
 
    p += sizeof(T);
  };
} // namespace detail
 
template <size_t M, size_t N>
class GenericParticle
{
public:
  inline GenericParticle();
 
  inline GenericParticle(const GenericParticle<M, N>& a_other);
 
  inline virtual ~GenericParticle();
 
  inline const int32_t&
  particleID() const noexcept;
 
  inline int32_t&
  particleID() noexcept;
 
  inline const int32_t&
  rankID() const noexcept;
 
  inline int32_t&
  rankID() noexcept;
 
  inline RealVect&
  position();
 
  inline const RealVect&
  position() const;
 
  inline const std::array<Real, M>&
  getReals() const noexcept;
 
  inline std::array<Real, M>&
  getReals() noexcept;
 
  inline const std::array<RealVect, N>&
  getVects() const noexcept;
 
  inline std::array<RealVect, N>&
  getVects() noexcept;
 
  template <size_t K>
  inline Real&
  real();
 
  template <size_t K>
  inline const Real&
  real() const;
 
  template <size_t K>
  inline RealVect&
  vect();
 
  template <size_t K>
  inline const RealVect&
  vect() const;
 
  inline bool
  operator==(const GenericParticle<M, N>& a_p) const;
 
  inline bool
  operator!=(const GenericParticle<M, N>& a_p) const;
 
  inline bool
  operator<(const GenericParticle<M, N>& a_other) const noexcept;
 
  inline virtual int
  size() const;
 
  inline virtual void
  linearOut(void* a_buffer) const;
 
  inline virtual void
  linearIn(const void* a_buffer);
 
  inline virtual int
  H5size() const;
 
  inline virtual void
  H5linearOut(void* a_buffer) const;
 
  inline virtual void
  H5linearIn(const void* a_buffer);
 
protected:
  int32_t m_particleID;
 
  int32_t m_rankID;
 
  RealVect m_position;
 
  std::array<Real, M> m_scalars;
 
  std::array<RealVect, N> m_vectors;
};
 
template <size_t M, size_t N>
inline std::ostream&
operator<<(std::ostream& ostr, const GenericParticle<M, N>& p);
 
#include <CD_NamespaceFooter.H>
 
#include <CD_GenericParticleImplem.H>
 
#endif