Initialize at openlb-1-3

1 files changed, 244 insertions, 0 deletions

diff --git a/src/core/superData3D.hh b/src/core/superData3D.hh
new file mode 100644
index 0000000..57d9ca7
--- /dev/null
+++ b/src/core/superData3D.hh
@@ -0,0 +1,244 @@
+/*  This file is part of the OpenLB library
+ *
+ *  Copyright (C) 2015 Mathias J. Krause, Benjamin Förster
+ *  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.
+*/
+
+/** \file
+ * Dynamics for a generic 3D super data -- header file.
+ */
+#ifndef SUPER_DATA_3D_HH
+#define SUPER_DATA_3D_HH
+
+#include <numeric>
+#include "superData3D.h"
+#include "functors/lattice/superBaseF3D.h"
+#include "geometry/cuboid3D.h"
+
+namespace olb {
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>::~SuperData3D()
+{
+  deConstruct();
+}
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>::SuperData3D(int size)
+  : SuperStructure3D<T> (),
+    _size(size)
+{
+}
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>::SuperData3D(CuboidGeometry3D<T>& cuboidGeometry,
+                                     LoadBalancer<T>& loadBalancer, int overlap, int size)
+  : SuperStructure3D<T>(cuboidGeometry, loadBalancer, overlap), _size(size)
+{
+  allocateMemory();
+}
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>::SuperData3D(SuperData3D<T,BaseType>& rhs)
+  : SuperStructure3D<T>(rhs.getCuboidGeometry(), rhs.getLoadBalancer(), rhs.getOverlap())
+{
+  // copy whole BlockData3D vector and size
+  _extendedBlockData = rhs._extendedBlockData;
+  _size = rhs._size;
+}
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>::SuperData3D(SuperF3D<T,BaseType>& rhs)
+  : SuperStructure3D<T>(rhs.getSuperStructure().getCuboidGeometry(),
+                        rhs.getSuperStructure().getLoadBalancer(),
+                        rhs.getSuperStructure().getOverlap()),
+    _size(rhs.getTargetDim())
+{
+  allocateMemory();
+  int i[4];
+  int iX, iY, iZ;
+  for (int iCloc=0; iCloc < this->getLoadBalancer().size(); ++iCloc) {
+    i[0] = this->getLoadBalancer().glob(iCloc);
+    for (iX=0; iX < get(iCloc).getNx(); iX++) {
+      for (iY=0; iY < get(iCloc).getNy(); iY++) {
+        for (iZ=0; iZ < get(iCloc).getNz(); iZ++) {
+          i[1] = iX - this->_overlap;
+          i[2] = iY - this->_overlap;
+          i[3] = iZ - this->_overlap;
+          BaseType tmp[rhs.getTargetDim()];
+          rhs(tmp, i);
+          for (int iDim=0; iDim<rhs.getTargetDim(); iDim++ ) {
+            get(iCloc).get(iX, iY, iZ, iDim) = tmp[iDim];
+          }
+        }
+      }
+    }
+  }
+}
+
+template<typename T, typename BaseType>
+void SuperData3D<T,BaseType>::allocateMemory()
+{
+  for (int iCloc=0; iCloc < this->getLoadBalancer().size(); ++iCloc) {
+    int iCglob = this->getLoadBalancer().glob(iCloc);
+    Cuboid3D<T> extendedCuboid(this->getCuboidGeometry().get(iCglob), this->getOverlap());
+    _extendedBlockData.emplace_back(extendedCuboid.getNx(),
+                                    extendedCuboid.getNy(),
+                                    extendedCuboid.getNz(),
+                                    _size);
+  }
+};
+
+template<typename T, typename BaseType>
+SuperData3D<T,BaseType>& SuperData3D<T,BaseType>::operator=(SuperData3D<T,BaseType>& rhs)
+{
+  // Swap content of rhs with local content
+  swap(rhs);
+  return *this;
+}
+
+template<typename T, typename BaseType>
+void SuperData3D<T,BaseType>::swap(std::vector< BlockData3D<T,BaseType> >& blockDatas)
+{
+  // Needed for vtiReader: After building geometry, vtiReader builds Block Data vector
+  if ( blockDatas.size() == 0 ) {
+    _size = 1;
+  }
+  else {
+    _size = blockDatas[0].getSize();
+  }
+  std::swap(_extendedBlockData, blockDatas);
+}
+
+template<typename T, typename BaseType>
+void SuperData3D<T,BaseType>::swap(SuperData3D<T,BaseType>& rhs)
+{
+  std::swap(_size, rhs._size);
+  _extendedBlockData.swap(rhs._extendedBlockData);
+}
+
+template<typename T, typename BaseType>
+bool SuperData3D<T,BaseType>::isConstructed() const
+{
+  // iterate through all blocks and check if isConstructed
+  bool superIsConstructed = true;
+  for (auto & blockData : _extendedBlockData) {
+    superIsConstructed &= blockData.isConstructed();
+  }
+  return superIsConstructed;
+}
+
+template<typename T, typename BaseType>
+void SuperData3D<T,BaseType>::deConstruct()
+{
+  // for all blocks: deConstruct
+  for (auto & blockData : _extendedBlockData) {
+    blockData.deConstruct();
+  }
+}
+
+template<typename T, typename BaseType>
+void SuperData3D<T,BaseType>::reset()
+{
+  // for all blocks: reset
+  for (auto & blockData : _extendedBlockData) {
+    blockData.reset();
+  }
+}
+
+template<typename T, typename BaseType>
+BlockData3D<T,BaseType>& SuperData3D<T,BaseType>::get(int iC)
+{
+  return _extendedBlockData[iC];
+}
+
+template<typename T, typename BaseType>
+BlockData3D<T,BaseType> const& SuperData3D<T,BaseType>::get(int iC) const
+{
+  return _extendedBlockData[iC];
+}
+
+template<typename T, typename BaseType>
+BaseType& SuperData3D<T,BaseType>::get(int iC, int iX, int iY, int iZ, int iData)
+{
+  return _extendedBlockData[iC].get(iX + this->_overlap,
+                                    iY + this->_overlap,
+                                    iZ + this->_overlap, iData);
+}
+
+template<typename T, typename BaseType>
+BaseType const& SuperData3D<T,BaseType>::get(int iC, int iX, int iY, int iZ, int iData) const
+{
+  return _extendedBlockData[iC].get(iX + this->_overlap,
+                                    iY + this->_overlap,
+                                    iZ + this->_overlap, iData);
+}
+
+template<typename T, typename BaseType>
+bool* SuperData3D<T,BaseType>::operator() (int iCloc, int iX, int iY, int iZ, int iData)
+{
+  return (bool*)&get(iCloc,iX,iY,iZ,iData);
+}
+
+template<typename T, typename BaseType>
+int SuperData3D<T,BaseType>::getDataSize() const
+{
+  return _size;
+}
+
+template<typename T, typename BaseType>
+int SuperData3D<T,BaseType>::getDataTypeSize() const
+{
+  return sizeof(BaseType);
+}
+
+
+template<typename T, typename BaseType>
+size_t SuperData3D<T,BaseType>::getNblock() const
+{
+  return 1 + std::accumulate(_extendedBlockData.begin(), _extendedBlockData.end(), size_t(0),
+                             Serializable::sumNblock());
+}
+
+template<typename T, typename BaseType>
+size_t SuperData3D<T,BaseType>::getSerializableSize() const
+{
+  return   sizeof(int) // _size
+           + std::accumulate(_extendedBlockData.begin(), _extendedBlockData.end(), size_t(0),
+                             Serializable::sumSerializableSize());
+};
+
+template<typename T, typename BaseType>
+bool* SuperData3D<T,BaseType>::getBlock(std::size_t iBlock, std::size_t& sizeBlock, bool loadingMode)
+{
+  std::size_t currentBlock = 0;
+  size_t sizeBufferIndex = 0;
+  bool* dataPtr = nullptr;
+
+  registerVar(iBlock, sizeBlock, currentBlock, dataPtr, _size);
+  registerStdVectorOfSerializablesOfConstSize(iBlock, sizeBlock, currentBlock, sizeBufferIndex, dataPtr,
+      _extendedBlockData, loadingMode);
+  return dataPtr;
+}
+
+
+}  // namespace olb
+
+#endif