descriptorBase.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2019 Adrian Kummerlaender, Mathias J. Krause
 *                2021 Adrian Kummerlaender, Nicolas Hafen, Mathias J. Krause
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef DESCRIPTOR_BASE_H
#define DESCRIPTOR_BASE_H
 
#include "descriptorTag.h"
#include "descriptorField.h"
#include "core/meta.h"
 
namespace olb {
 
namespace descriptors {
 
template <typename FIELD>
using is_data_field = std::integral_constant<bool, !is_tag_field<FIELD>::value>;
 
 
 
struct TYPE_LATTICE;
struct TYPE_PARTICLE;
 
 
template <typename... FIELDS>
struct FIELD_TUPLE : public meta::list<FIELDS...> {
  FIELD_TUPLE() = delete;
 
  using fields_t = meta::list<FIELDS...>;
 
  template <template<typename...> class COLLECTION>
  using decompose_into = COLLECTION<FIELDS...>;
 
  static constexpr std::size_t field_count = sizeof...(FIELDS);
 
  template <template<typename> class COND>
  using filter = typename meta::filter_t<COND, FIELDS...>
    ::template decompose_into<FIELD_TUPLE>;
 
  template <typename WANTED_FIELD>
  static constexpr bool provides()
  {
    return meta::contains<WANTED_FIELD,FIELDS...>();
  }
 
  static bool provides(std::type_index field)
  {
    return meta::contains<FIELDS...>(field);
  }
 
};
 
template <unsigned... PARAMS>
struct PARAMETER_TUPLE {
  template <typename FIELD>
  static constexpr std::size_t size() {
    return FIELD::template size<PARAMS...>();
  };
};
 
template <typename PARAMETERS, typename... FIELDS>
struct CONCRETE_FIELD_TUPLE : public FIELD_TUPLE<FIELDS...> {
  using parameter_tuple_t = PARAMETERS;
 
 
  template<typename BASE>
  using derivedField = std::conditional_t<
    meta::contains<
      typename meta::list_item_with_base_default_base<BASE,FIELDS...>::type,
      FIELDS...
    >(),
    typename meta::list_item_with_base_default_base<BASE,FIELDS...>::type,
    void
  >;
 
 
  template <typename ...NESTED_FIELDS>
  static constexpr bool providesNested()
  {
    return meta::derived_type_in_nested<CONCRETE_FIELD_TUPLE, NESTED_FIELDS...>::contains();
  }
 
 
  template <typename FIELD = void>
  static constexpr std::size_t size()
  {
    if constexpr (std::is_void_v<FIELD>) {
      return (parameter_tuple_t::template size<FIELDS>() + ... + 0);
    } else {
      return parameter_tuple_t::template size<FIELD>();
    }
    __builtin_unreachable();
  }
};
 
template <unsigned D, typename... FIELDS>
struct SPATIAL_DESCRIPTOR : public CONCRETE_FIELD_TUPLE<PARAMETER_TUPLE<D>, FIELDS...> {
  static constexpr int d = D;
};
 
struct LATTICE_DESCRIPTOR_BASE { };
 
template <unsigned D, unsigned Q, typename... FIELDS>
struct LATTICE_DESCRIPTOR : public LATTICE_DESCRIPTOR_BASE
                          , public CONCRETE_FIELD_TUPLE<PARAMETER_TUPLE<D,Q>, FIELDS...> {
  using type = TYPE_LATTICE;
  static constexpr int d = D;
  static constexpr int q = Q;
 
  using all_t = meta::list<FIELDS...>;
  using fields_t = meta::filter_t<is_data_field, FIELDS...>;
  using tags_t   = meta::filter_t<is_tag_field, FIELDS...>;
 
 
  using category_tag = typename tags_t::template first_with_base_or_fallback<tag::CATEGORY, tag::DEFAULT>;
 
};
 
template <typename T, typename DESCRIPTOR>
struct VALUED_DESCRIPTOR {
  using value_t = T;
  using descriptor_t = DESCRIPTOR;
};
 
 
template <typename TYPE>
using extract_valued_descriptor_t = VALUED_DESCRIPTOR<
  typename std::remove_reference_t<TYPE>::value_t,
  typename std::remove_reference_t<TYPE>::descriptor_t
>;
 
 
template <unsigned D, typename... FIELDS>
struct PARTICLE_DESCRIPTOR : public CONCRETE_FIELD_TUPLE<PARAMETER_TUPLE<D>, FIELDS...> {
  using type = TYPE_PARTICLE;
  static constexpr int d = D;
 
};
 
 
}
 
}
 
#endif