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/functors/lattice/superLatticeIntegralF2D.hh | 346 ++++++++++++++++++++++++ 1 file changed, 346 insertions(+) create mode 100644 src/functors/lattice/superLatticeIntegralF2D.hh (limited to 'src/functors/lattice/superLatticeIntegralF2D.hh') diff --git a/src/functors/lattice/superLatticeIntegralF2D.hh b/src/functors/lattice/superLatticeIntegralF2D.hh new file mode 100644 index 0000000..87aee15 --- /dev/null +++ b/src/functors/lattice/superLatticeIntegralF2D.hh @@ -0,0 +1,346 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2014 Albert Mink, Mathias J. Krause, Adrian Kummerlaender + * 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. +*/ + +#ifndef SUPER_LATTICE_INTEGRAL_F_2D_HH +#define SUPER_LATTICE_INTEGRAL_F_2D_HH + +#include +#include + +#include "superLatticeIntegralF2D.h" +#include "blockLatticeIntegralF2D.h" +#include "indicator/superIndicatorF2D.h" +#include "utilities/vectorHelpers.h" +#include "core/vector.h" + +using namespace olb::util; + +namespace olb { + + +template +SuperMax2D::SuperMax2D(SuperF2D& f, SuperGeometry2D& superGeometry, const int material) + : SuperF2D(f.getSuperStructure(),f.getTargetDim()), + _f(f), _superGeometry(superGeometry), _material(material) +{ + this->getName() = "Max("+_f.getName()+")"; +} + +template +bool SuperMax2D::operator() (T output[], const int input[]) +{ + _f.getSuperStructure().communicate(); + CuboidGeometry2D& cGeometry = _f.getSuperStructure().getCuboidGeometry(); + LoadBalancer& load = _f.getSuperStructure().getLoadBalancer(); + + for (int i = 0; i < this->getTargetDim(); ++i) { + output[i]=T(); + for (int iC = 0; iC < load.size(); ++iC) { + int nX = cGeometry.get(load.glob(iC)).getNx(); + int nY = cGeometry.get(load.glob(iC)).getNy(); + for (int iX = 0; iX < nX; iX++) { + for (int iY = 0; iY < nY; iY++) { + if (_superGeometry.get(load.glob(iC), iX, iY) == _material) { + T outputTmp[_f.getTargetDim()]; + _f(outputTmp,load.glob(iC),iX,iY); + if (fabs(outputTmp[i]) > output[i]) { + output[i] = fabs(outputTmp[i]); + } + } + } + } + } +#ifdef PARALLEL_MODE_MPI + singleton::mpi().reduceAndBcast(output[i], MPI_MAX); +#endif + } + return true; +} + +template +SuperMin2D::SuperMin2D(SuperF2D& f, SuperGeometry2D& superGeometry, const int material) + : SuperF2D(f.getSuperStructure(),f.getTargetDim()), + _f(f), _superGeometry(superGeometry), _material(material) +{ + this->getName() = "Min("+_f.getName()+")"; +} + +template +bool SuperMin2D::operator() (T output[], const int input[]) +{ + _f.getSuperStructure().communicate(); + CuboidGeometry2D& cGeometry = _f.getSuperStructure().getCuboidGeometry(); + LoadBalancer& load = _f.getSuperStructure().getLoadBalancer(); + + for (int i = 0; i < this->getTargetDim(); ++i) { + output[i]=T(); + for (int iC = 0; iC < load.size(); ++iC) { + int nX = cGeometry.get(load.glob(iC)).getNx(); + int nY = cGeometry.get(load.glob(iC)).getNy(); + for (int iX = 0; iX < nX; iX++) { + for (int iY = 0; iY < nY; iY++) { + if (_superGeometry.get(load.glob(iC), iX, iY) == _material) { + T outputTmp[_f.getTargetDim()]; + _f(outputTmp,load.glob(iC),iX,iY); + if (fabs(outputTmp[i]) < output[i]) { + output[i] = fabs(outputTmp[i]); + } + } + } + } + } +#ifdef PARALLEL_MODE_MPI + singleton::mpi().reduceAndBcast(output[i], MPI_MAX); +#endif + } + return true; +} + + +template +SuperSum2D::SuperSum2D(SuperF2D& f, SuperGeometry2D& superGeometry, const int material) + : SuperF2D(f.getSuperStructure(),f.getTargetDim()+1), + _f(f), _superGeometry(superGeometry), _material(material) +{ + this->getName() = "Sum("+_f.getName()+")"; +} + +template +bool SuperSum2D::operator() (T output[], const int input[]) +{ + _f.getSuperStructure().communicate(); + CuboidGeometry2D& cGeometry = _f.getSuperStructure().getCuboidGeometry(); + LoadBalancer& load = _f.getSuperStructure().getLoadBalancer(); + + int numVoxels(0); + for (int i = 0; i < this->getTargetDim(); ++i) { + output[i]=T(); + } + for (int iC=0; iC_superGeometry.get(load.glob(iC), iX, iY) == _material) { + T outputTmp[_f.getTargetDim()]; + _f(outputTmp,load.glob(iC),iX,iY); + for (int i = 0; i < this->getTargetDim()-1 /*f.getTargetDim()*/; ++i) { + output[i] += outputTmp[i]; + } + numVoxels++; + } + } + } + } +#ifdef PARALLEL_MODE_MPI + for (int i = 0; i < this->getTargetDim()-1; ++i) { + singleton::mpi().reduceAndBcast(output[i], MPI_SUM); + } + singleton::mpi().reduceAndBcast(numVoxels, MPI_SUM); +#endif + output[this->getTargetDim()-1] = numVoxels; + return true; +} + + +template +SuperIntegral2D::SuperIntegral2D(SuperF2D& f, SuperGeometry2D& superGeometry, const int material) + : SuperF2D(f.getSuperStructure(),f.getTargetDim()), _f(f), _superGeometry(superGeometry), _material(material) +{ + this->getName() = "Integral("+_f.getName()+")"; +} + +template +bool SuperIntegral2D::operator() (T output[], const int input[]) +{ + // f.getSuperStructure().communicate(); + // CuboidGeometry2D& cGeometry = f.getSuperStructure().getCuboidGeometry(); + // LoadBalancer& load = f.getSuperStructure().getLoadBalancer(); + + // std::vector tmp(this->_n, T() ); + // for (int i=0; i_n; ++i) { + // for (int iC=0; iCsuperGeometry.getDeltaR(),3); + // for (int iX=0; iXsuperGeometry.getMaterial(globX, globY) == material) { + //// tmp[i]+=f(load.glob(iC),iX,iY)[i]*weight; + //// } + //// if (this->superGeometry.getMaterial(globX, globY, globZ) == material) { + //// tmp[i]+=f(load.glob(iC),iX,iY,iZ)[i]*weight; + //// } + + //// } + // } + // } + // } + //#ifdef PARALLEL_MODE_MPI + // singleton::mpi().reduceAndBcast(tmp[i], MPI_SUM); + //#endif + // } + // return tmp; + return false; +} + + +template +template +SuperGeometryFaces2D::SuperGeometryFaces2D(SuperGeometry2D& superGeometry, + const int material, const UnitConverter& converter) + : GenericF(7,3), _superGeometry(superGeometry), _material(material), _latticeL(converter.getConversionFactorLength()) +{ + this->getName() = "superGeometryFaces"; +} + +template +SuperGeometryFaces2D::SuperGeometryFaces2D(SuperGeometry2D& superGeometry, + const int material, T latticeL) + : GenericF(7,3), _superGeometry(superGeometry), _material(material), _latticeL(latticeL) +{ + this->getName() = "superGeometryFaces"; +} + + + +template +bool SuperGeometryFaces2D::operator() (T output[], const int input[]) +{ + for (int iDim = 0; iDim < 7; ++iDim) { + output[iDim]=T(); + } + _superGeometry.communicate(); + for (int iC = 0; iC < _superGeometry.getLoadBalancer().size(); ++iC) { + BlockGeometryFaces2D f(_superGeometry.getBlockGeometry(iC), _material, _latticeL); + T outputTmp[f.getTargetDim()]; + f(outputTmp,input); + for (int iDim = 0; iDim < 7; ++iDim) { + output[iDim] += outputTmp[iDim]; + } + } +#ifdef PARALLEL_MODE_MPI + for (int iDim = 0; iDim < 7; ++iDim) { + singleton::mpi().reduceAndBcast( output[iDim], MPI_SUM); + } +#endif + return true; +} + +template +SuperGeometryFacesIndicator2D::SuperGeometryFacesIndicator2D(SuperGeometry2D& superGeometry, + SmoothIndicatorF2D& indicator, const int material, T deltaX) + : GenericF(7,0), _superGeometry(superGeometry), _indicator(indicator), _material(material), _latticeL(deltaX) +{ + this->getName() = "superGeometryFacesInd"; +} + +template +bool SuperGeometryFacesIndicator2D::operator() (T output[], const int input[]) +{ + _superGeometry.communicate(); + for (int iDim = 0; iDim < 7; ++iDim) { + output[iDim]=T(); + } + for (int iC = 0; iC < _superGeometry.getLoadBalancer().size(); ++iC) { + BlockGeometryFacesIndicator2D f(_superGeometry.getBlockGeometry(iC), _indicator, _material, _latticeL); + T outputTmp[f.getTargetDim()]; + f(outputTmp,input); + for (int iDim = 0; iDim < 7; ++iDim) { + output[iDim] += outputTmp[iDim]; + } + } +#ifdef PARALLEL_MODE_MPI + for (int iDim = 0; iDim < 7; ++iDim) { + singleton::mpi().reduceAndBcast( output[iDim], MPI_SUM); + } +#endif + return true; +} + + +template +SuperLatticePhysDrag2D::SuperLatticePhysDrag2D +(SuperLattice2D& sLattice, SuperGeometry2D& superGeometry, + const int material, const UnitConverter& converter) + : SuperLatticePhysF2D(sLattice,converter,2), + _superGeometry(superGeometry), _material(material) +{ + this->getName() = "physDrag"; +} + +template +bool SuperLatticePhysDrag2D::operator() (T output[], const int input[]) +{ + SuperGeometryFaces2D faces(_superGeometry, _material, this->_converter.getConversionFactorLength()); + SuperLatticePhysBoundaryForce2D f(this->_sLattice, _superGeometry, _material, this->_converter); + SuperSum2D sumF(f, _superGeometry, _material); + + T factor = 2. / (this->_converter.getPhysDensity() * this->_converter.getCharPhysVelocity() * this->_converter.getCharPhysVelocity()); + + T facesTmp[faces.getTargetDim()], sumFTmp[sumF.getTargetDim()]; + sumF(sumFTmp, input); + faces(facesTmp, input); + output[0] = factor * sumFTmp[0] / facesTmp[0]; + output[1] = factor * sumFTmp[1] / facesTmp[1]; + + return true; +} + +template +SuperLatticePhysCorrDrag2D::SuperLatticePhysCorrDrag2D +(SuperLattice2D& sLattice, SuperGeometry2D& superGeometry, + const int material, const UnitConverter& converter) + : SuperLatticePhysF2D(sLattice,converter,2), + _superGeometry(superGeometry), _material(material) +{ + this->getName() = "physCorrDrag"; +} + +template +bool SuperLatticePhysCorrDrag2D::operator() (T output[], const int input[]) +{ + // SuperGeometryFaces2D faces(superGeometry, material, this->converter); + + // SuperLatticePhysCorrBoundaryForce2D f(this->sLattice, superGeometry, material, this->converter); + // SuperSum2D sumF(f, superGeometry, material); + + // T factor = 2. / (this->converter.getCharRho() * this->converter.getCharU() * this->converter.getCharU()); + + // std::vector drag(2,T()); + // drag[0] = factor * sumF(input)[0] / faces(input)[0]; + // drag[1] = factor * sumF(input)[1] / faces(input)[1]; + //// drag[2] = factor * sumF(input)[2] / faces(input)[2]; + // return drag; + return false; +} + + +} //end namespace olb + +#endif -- cgit v1.2.3