Initialize at openlb-1-3

1 files changed, 215 insertions, 0 deletions

diff --git a/src/core/superData2D.hh b/src/core/superData2D.hh
new file mode 100644
index 0000000..b99580b
--- /dev/null
+++ b/src/core/superData2D.hh
@@ -0,0 +1,215 @@
+/*  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 2D super data -- header file.
+ */
+#ifndef SUPER_DATA_2D_HH
+#define SUPER_DATA_2D_HH
+
+#include "superData2D.h"
+#include "geometry/cuboid2D.h"
+#include "geometry/cuboidGeometry2D.h"
+#include "functors/lattice/superBaseF2D.h"
+
+namespace olb {
+
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>::~SuperData2D()
+{
+  deConstruct();
+}
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>::SuperData2D(int size) : SuperStructure2D<T> (), _size(size)
+{
+//  std::cout << "/// SuperData2D ctor" << std::endl;
+}
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>::SuperData2D(CuboidGeometry2D<T>& cuboidGeometry,
+                                     LoadBalancer<T>& loadBalancer, int overlap, int size)
+  : SuperStructure2D<T>(cuboidGeometry, loadBalancer, overlap), _size(size)
+{
+//  std::cout << "/// SuperData2D ctor" << std::endl;
+  allocateMemory();
+}
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>::SuperData2D(SuperData2D<T,BaseType>& rhs)
+  : SuperStructure2D<T>(rhs.getCuboidGeometry(), rhs.getLoadBalancer(), rhs.getOverlap())
+{
+//  std::cout << "/// SuperData2D copy ctor" << std::endl;
+  // copy whole BlockData2D vector and size
+  _extendedBlockData = rhs._extendedBlockData;
+  _size = rhs._size;
+}
+
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>::SuperData2D(SuperF2D<T,BaseType>& rhs)
+  : SuperStructure2D<T>(rhs.getSuperStructure().getCuboidGeometry(),
+                        rhs.getSuperStructure().getLoadBalancer(),
+                        rhs.getSuperStructure().getOverlap()),
+    _size(rhs.getTargetDim())
+{
+//  std::cout << "/// SuperData2D ctor" << std::endl;
+  allocateMemory();
+
+  int i[3];
+  int iX, iY;
+  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++) {
+        i[1] = iX - this->_overlap;
+        i[2] = iY - this->_overlap;
+        BaseType tmp[rhs.getTargetDim()];
+        rhs(tmp, i);
+        for (int iDim=0; iDim<rhs.getTargetDim(); iDim++) {
+          get(iCloc).get(iX, iY, iDim) = (BaseType)(tmp[iDim]);
+        }
+      }
+    }
+  }
+}
+
+template<typename T, typename BaseType>
+SuperData2D<T,BaseType>& SuperData2D<T,BaseType>::operator=(SuperData2D<T,BaseType>& rhs)
+{
+  // Swap content of rhs with local content
+  swap(rhs);
+  return *this;
+}
+
+template<typename T, typename BaseType>
+void SuperData2D<T,BaseType>::allocateMemory()
+{
+  if (_extendedBlockData.size() == 0) {
+    _extendedBlockData.reserve( this->getLoadBalancer().size() ); // speed up
+    for (int iCloc = 0; iCloc < this->getLoadBalancer().size(); ++iCloc) {
+      int iCglob = this->getLoadBalancer().glob(iCloc);
+      Cuboid2D<T> extendedCuboid(this->getCuboidGeometry().get(iCglob), this->getOverlap());
+      _extendedBlockData.emplace_back(extendedCuboid.getNx(),
+                                      extendedCuboid.getNy(),
+                                      _size);
+    }
+  }
+}
+
+template<typename T, typename BaseType>
+void SuperData2D<T,BaseType>::swap(std::vector< BlockData2D<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 SuperData2D<T,BaseType>::swap(SuperData2D<T,BaseType>& rhs)
+{
+  std::swap(_size, rhs._size);
+  _extendedBlockData.swap(rhs._extendedBlockData);
+}
+
+template<typename T, typename BaseType>
+bool SuperData2D<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 SuperData2D<T,BaseType>::deConstruct()
+{
+  // for all blocks: deConstruct
+  for (auto & blockData : _extendedBlockData) {
+    blockData.deConstruct();
+  }
+}
+
+template<typename T, typename BaseType>
+void SuperData2D<T,BaseType>::reset()
+{
+  // for all blocks: reset
+  for (auto & blockData : _extendedBlockData) {
+    blockData.reset();
+  }
+}
+
+template<typename T, typename BaseType>
+BlockData2D<T,BaseType>& SuperData2D<T,BaseType>::get(int iC)
+{
+  return _extendedBlockData[iC];
+}
+
+template<typename T, typename BaseType>
+BlockData2D<T,BaseType> const& SuperData2D<T,BaseType>::get(int iC) const
+{
+  return _extendedBlockData[iC];
+}
+
+template<typename T, typename BaseType>
+BaseType& SuperData2D<T,BaseType>::get(int iC, int iX, int iY, int iData)
+{
+  return _extendedBlockData[iC].get(iX + this->_overlap, iY + this->_overlap, iData);
+}
+
+template<typename T, typename BaseType>
+BaseType const& SuperData2D<T,BaseType>::get(int iC, int iX, int iY, int iData) const
+{
+  return _extendedBlockData[iC].get(iX + this->_overlap, iY + this->_overlap, iData);
+}
+
+template<typename T, typename BaseType>
+bool* SuperData2D<T,BaseType>::operator() (int iCloc, int iX, int iY, int iData)
+{
+  return (bool*)&get(iCloc,iX,iY,iData);
+}
+
+template<typename T, typename BaseType>
+int SuperData2D<T,BaseType>::getDataSize() const
+{
+  return _size;
+}
+
+template<typename T, typename BaseType>
+int SuperData2D<T,BaseType>::getDataTypeSize() const
+{
+  return sizeof(BaseType);
+}
+
+
+}  // namespace olb
+
+#endif