operator.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2021 Adrian Kummerlaender
 *  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 CORE_OPERATOR_H
#define CORE_OPERATOR_H
 
namespace olb {
 
template <typename T, typename DESCRIPTOR, Platform PLATFORM> class ConcreteBlockLattice;
template <typename T, Platform PLATFORM> class ConcreteBlockMask;
 
struct AbstractBlockO {
  virtual ~AbstractBlockO() = default;
 
  virtual std::type_index id() const = 0;
};
 
template <typename T, typename DESCRIPTOR, Platform PLATFORM>
struct BlockO : public AbstractBlockO {
  virtual void set(CellID iCell, bool state) = 0;
  virtual void setup(ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>& block) = 0;
  virtual void apply(ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>& block) = 0;
};
 
 
enum struct OperatorScope {
  PerCell,
  PerBlock,
  PerCellWithParameters,
};
 
template<typename T, typename DESCRIPTOR, Platform PLATFORM, typename OPERATOR, OperatorScope SCOPE>
class ConcreteBlockO;
 
template <typename T, typename DESCRIPTOR>
struct AbstractCollisionO : public AbstractBlockO {
  virtual Dynamics<T,DESCRIPTOR>* getDynamics() = 0;
 
 
  virtual std::size_t weight() const = 0;
 
  virtual void set(CellID iCell, bool state, bool overlap) = 0;
};
 
enum struct CollisionDispatchStrategy {
  Dominant,
  Individual
};
 
template <typename T, typename DESCRIPTOR, Platform PLATFORM>
struct BlockCollisionO : public AbstractCollisionO<T,DESCRIPTOR> {
  virtual void setup(ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>& block) = 0;
 
  virtual void apply(ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>& block,
                     ConcreteBlockMask<T,PLATFORM>&               subdomain,
                     CollisionDispatchStrategy                    strategy) = 0;
};
 
template<typename T, typename DESCRIPTOR, Platform PLATFORM, typename DYNAMICS>
class ConcreteBlockCollisionO;
 
template <typename COUPLEES>
struct AbstractCouplingO : public AbstractBlockO {
  using value_t      = typename COUPLEES::values_t::template get<0>::value_t;
  using descriptor_t = typename COUPLEES::values_t::template get<0>::descriptor_t;
 
  using AbstractParameters = olb::AbstractParameters<value_t,descriptor_t>;
  using ParametersD = olb::ParametersD<value_t,descriptor_t>;
 
  using LatticeR = olb::LatticeR<descriptor_t::d>;
  template <typename FIELD>
  using FieldD = olb::FieldD<value_t,descriptor_t,FIELD>;
 
  virtual void execute() = 0;
  virtual AbstractParameters& getParameters() = 0;
 
  virtual void set(CellID iCell, bool state) = 0;
 
};
 
template<typename COUPLEES, Platform PLATFORM, typename OPERATOR, OperatorScope SCOPE>
class ConcreteBlockCouplingO;
 
 
}
 
#endif