From 94d3e79a8617f88dc0219cfdeedfa3147833719d Mon Sep 17 00:00:00 2001 From: Adrian Kummerlaender Date: Mon, 24 Jun 2019 14:43:36 +0200 Subject: Initialize at openlb-1-3 --- src/core/superLattice3D.h | 357 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 357 insertions(+) create mode 100644 src/core/superLattice3D.h (limited to 'src/core/superLattice3D.h') diff --git a/src/core/superLattice3D.h b/src/core/superLattice3D.h new file mode 100644 index 0000000..b6a36d5 --- /dev/null +++ b/src/core/superLattice3D.h @@ -0,0 +1,357 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2007 Mathias J. Krause + * E-mail contact: info@openlb.net + * The most recent release of OpenLB can be downloaded at + * + * + * 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. + */ + +/** \file + * The description of a 3D super lattice -- header file. + */ + +#ifndef SUPER_LATTICE_3D_H +#define SUPER_LATTICE_3D_H + +#include + +#include "blockLattice3D.h" +#include "blockLatticeView3D.h" +#include "superData3D.h" +#include "communication/communicator3D.h" +#include "postProcessing.h" +#include "serializer.h" +#include "communication/superStructure3D.h" +#include "utilities/functorPtr.h" + +/// All OpenLB code is contained in this namespace. +namespace olb { + +template class SuperLatticeF3D; +template class AnalyticalF3D; +template class SuperGeometry3D; +template class SuperIndicatorF3D; +template class LoadBalancer; +template class CuboidGeometry3D; +template class IndicatorSphere3D; +template class Communicator3D; +template class BlockLatticeView3D; + + +/// A super lattice combines a number of block lattices that are ordered +/// in a cuboid geometry. +/** The communication between the block lattices is done by two + * communicators. One (_commStream) is responsible to provide the data for + * the streaming the other (_commBC) for the non-local boundary conditions. + * To simplify the code structure ghost cells in an overlap of size + * (_overlap) is introduced. It depends on the non-locality of the + * boundary conditions but is at least one because of the streaming + * + * The algorithm is parallelized with mpi. The load balancer (_loadBalancer) + * distributes the block lattices to processes. + * + * WARNING: For unstructured grids there is an interpolation needed + * for the method buffer_outData in cuboidNeighbourhood which is not + * yet implemented! Moreover this class needs to be changed so + * that the number of times steps for the collision and streaming is + * is dependent of the refinement level. + * + * This class is not intended to be derived from. + */ +template +class SuperLattice3D : public SuperStructure3D, public BufferSerializable { + +private: + /// Lattices with ghost cell layer of size overlap + std::vector > _extendedBlockLattices; + /// View of the lattices without overlap + std::vector > _blockLattices; + + /// This communicator handles the communication for the streaming + Communicator3D _commStream; + /// This communicator handles the communication for the postprocessors + Communicator3D _commBC; + /// Specifies if there is communication for non local boundary conditions + /// needed. It is automatically switched on if overlapBC >= 1 by + /// calling the constructor. (default =false) + bool _commBC_on; + /// Statistic of the super structure + LatticeStatistics *_statistics; + /// Specifies if there is statistic calculated. It is always + /// needed for the ConstRhoBGK dynamics. (default =true) + bool _statistics_on; + +public: + /// Construction of a super lattice + SuperLattice3D(SuperGeometry3D& superGeometry); + SuperLattice3D(const SuperLattice3D&) = delete; + ~SuperLattice3D() override; + /// Read and write access to a block lattice + BlockLattice3D& getExtendedBlockLattice(int locIC) + { + return _extendedBlockLattices[locIC]; + } + ; + /// Read only access to a block lattice + BlockLattice3D const& getExtendedBlockLattice(int locIC) const + { + return _extendedBlockLattices[locIC]; + } + ; + /// Read and write access to a lattice (block lattice view, one + /// without overlap). + BlockLatticeView3D& getBlockLattice(int locIC) + { + return _blockLattices[locIC]; + } + ; + /// Read only access to a lattice + BlockLatticeView3D const& getBlockLattice(int locIC) const + { + return _blockLattices[locIC]; + } + ; + + /// Read and write access to the boundary communicator + Communicator3D& get_commBC() + { + return _commBC; + } + ; + /// Read only access to the boundary communicator + Communicator3D const& get_commBC() const + { + return _commBC; + } + ; + + /// Return a handle to the LatticeStatistics object + LatticeStatistics& getStatistics(); + /// Return a constant handle to the LatticeStatistics object + LatticeStatistics const& getStatistics() const; + + /// Write access to lattice cells that returns false if + /// (iX/iY/iZ) is not in any of the cuboids + bool set(T iX, T iY, T iZ, Cell const& cell); + /// Read only access to lattice cells that returns false if + /// (iX/iY/iZ) is not in any of the cuboids + bool get(T iX, T iY, T iZ, Cell& cell) const; + /// Read only access to lattice cells over the cuboid number + /// and local coordinates WARNING!!! NO ERROR HANDLING IMPLEMENTED!!! + Cell get(int iC, int locX, int locY, int locZ) const; + Cell get(std::vector latticeR) const; + + /// Write access to the memory of the data of the super structure + bool* operator() (int iCloc, int iX, int iY, int iZ, int iData) override + { + return (bool*)&getExtendedBlockLattice(iCloc).get(iX+this->_overlap, iY+this->_overlap, iZ+this->_overlap)[iData]; + }; + /// Read only access to the dim of the data of the super structure + int getDataSize() const override + { + return DESCRIPTOR::q; + }; + /// Read only access to the data type dim of the data of the super structure + int getDataTypeSize() const override + { + return sizeof(T); + }; + + /// Initialize all lattice cells to become ready for simulation + void initialize(); + + /// Define the dynamics on a domain described by an indicator + void defineDynamics(FunctorPtr>&& indicator, Dynamics* dynamics); + /// Define the dynamics on a domain with a particular material number + void defineDynamics(SuperGeometry3D& sGeometry, int material, + Dynamics* dynamics); + + /// Define rho on a domain described by an indicator + /** + * \param indicator Indicator describing the target domain + * \param rho Analytical functor + **/ + void defineRho(FunctorPtr>&&, AnalyticalF3D& rho); + /// Define rho on a domain with a particular material number + void defineRho(SuperGeometry3D& sGeometry, int material, AnalyticalF3D& rho); + + /// Define u on a domain described by an indicator + /** + * \param indicator Indicator describing the target domain + * \param u Analytical functor + **/ + void defineU(FunctorPtr>&& indicator, AnalyticalF3D& u); + /// Define u on a domain with a particular material number + void defineU(SuperGeometry3D& sGeometry, int material, AnalyticalF3D& u); + + /// Define rho and u on a domain described by an indicator + /** + * \param indicator Indicator describing the target domain + * \param rho Analytical functor + * \param u Analytical functor + **/ + void defineRhoU(FunctorPtr>&& indicator, + AnalyticalF3D& rho, AnalyticalF3D& u); + /// Define rho and u on a domain with a particular material number + void defineRhoU(SuperGeometry3D& sGeometry, int material, + AnalyticalF3D& rho, AnalyticalF3D& u); + + /// Define a population on a domain described by an indicator + /** + * \param indicator Indicator describing the target domain + * \param Pop Analytical functor, target dimension DESCRIPTOR::q + **/ + void definePopulations(FunctorPtr>&& indicator, + AnalyticalF3D& Pop); + /// Define a population on a domain with a particular material number + void definePopulations(SuperGeometry3D& sGeometry, int material, + AnalyticalF3D& Pop); + /** + * \param indicator Indicator describing the target domain + * \param Pop Super functor, target dimension DESCRIPTOR::q + **/ + void definePopulations(FunctorPtr>&& indicator, + SuperF3D& Pop); + /// Define a population on a domain with a particular material number + void definePopulations(SuperGeometry3D& sGeometry, int material, + SuperF3D& Pop); + + /// Define an external field on a domain with a particular material number + template + void defineField(SuperGeometry3D& sGeometry, int material, + SuperF3D& field); + + /// Defines a field on a domain described by an indicator + template + void defineField(FunctorPtr>&& indicator, + AnalyticalF3D& field) + { + for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) { + _extendedBlockLattices[iC].template defineField( + indicator->getExtendedBlockIndicatorF(iC), field); + } + } + /// Defines a field on a domain with a particular material number + template + void defineField(SuperGeometry3D& sGeometry, int material, + AnalyticalF3D& field) + + { + defineField(sGeometry.getMaterialIndicator(material), field); + } + /// Defines a field on a indicated domain + template + void defineField(SuperGeometry3D& sGeometry, IndicatorF3D& indicator, + AnalyticalF3D& field); + + /// Initialize by equilibrium on a domain described by an indicator + /** + * \param indicator Indicator describing the target domain + * \param rho Analytical functor (global) + * \param u Analytical functor (global) + **/ + void iniEquilibrium(FunctorPtr>&& indicator, + AnalyticalF3D& rho, AnalyticalF3D& u); + /// Initialize by equilibrium on a domain with a particular material number + void iniEquilibrium(SuperGeometry3D& sGeometry, int material, + AnalyticalF3D& rho, AnalyticalF3D& u); +#ifndef OLB_PRECOMPILED + void setExternalParticleField(SuperGeometry3D& sGeometry, AnalyticalF3D& velocity, + SmoothIndicatorF3D& sIndicator); +#else + void setExternalParticleField(SuperGeometry3D& sGeometry, AnalyticalF3D& velocity, + SmoothIndicatorF3D& sIndicator) {}; +#endif + + /// Apply collision step to a rectangular domain + void collide(T x0, T x1, T y0, T y1, T z0, T z1); + /// Apply collision step to the whole domain + void collide(); + /// Apply streaming step to a rectangular domain + void stream(T x0, T x1, T y0, T y1, T z0, T z1); + /// Apply streaming step to the whole domain + void stream(); + /// TO BE DONE: Apply first collision, then streaming step + /// to a rectangular domain + // void collideAndStream(T x0, T x1, T y0, T y1, T z0, T z1); + /// Apply first collision, then streaming step + /// to the whole domain + void collideAndStream(); + /// Subtract a constant offset from the density within the whole domain + void stripeOffDensityOffset ( + int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, T offset ); + /// Subtract a constant offset from the density within a rect. domain + void stripeOffDensityOffset(T offset); + /// Switches Statistics on (default on) + void statisticsOn() + { + _statistics_on = true; + }; + /// Switches Statistics off (default on). That speeds up + /// the execution time. + void statisticsOff() + { + _statistics_on = false; + }; + + /// Adds a coupling generator for one partner superLattice + template + void addLatticeCoupling(LatticeCouplingGenerator3D const& lcGen, + SuperLattice3D& partnerLattice ); + /// Adds a coupling generator for one partner superLattice + template + void addLatticeCoupling(FunctorPtr>&& indicator, + LatticeCouplingGenerator3D const& lcGen, + SuperLattice3D& partnerLattice ); + /// Adds a coupling generator for one partner superLattice + template + void addLatticeCoupling(SuperGeometry3D& sGeometry, int material, + LatticeCouplingGenerator3D const& lcGen, + SuperLattice3D& partnerLattice ); + /// Adds a coupling generator for a multiple partner superLattice + template + void addLatticeCoupling(LatticeCouplingGenerator3D const& lcGen, + std::vector*> partnerLattices ); + /// Adds a coupling generator for a multiple partner superLattice + template + void addLatticeCoupling(FunctorPtr>&& indicator, + LatticeCouplingGenerator3D const& lcGen, + std::vector*> partnerLattices ); + /// Adds a coupling generator for a multiple partner superLattice + template + void addLatticeCoupling(SuperGeometry3D& sGeometry, int material, + LatticeCouplingGenerator3D const& lcGen, + std::vector*> partnerLattices ); + /// Executes coupling generator for one partner superLattice + void executeCoupling(); + + /// Number of data blocks for the serializable interface + std::size_t getNblock() const override; + /// Binary size for the serializer + std::size_t getSerializableSize() const override; + /// Return a pointer to the memory of the current block and its size for the serializable interface + bool* getBlock(std::size_t iBlock, std::size_t& sizeBlock, bool loadingMode) override; + +private: + /// Resets and reduce the statistics + void reset_statistics(); +}; + +} // namespace olb + +#endif -- cgit v1.2.3