smoothingFunctionals3D.h

Go to the documentation of this file.

/*  Lattice Boltzmann sample, written in C++, using the OpenLB
 *  library
 *
 *  Copyright (C) 2019 Davide Dapelo
 *  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.
 */
 
/* Smoothings functionals for Lagrangian two-way coupling methods -- header file.
 */
 
#ifndef LB_SMOOTHING_FUNCTIONALS_3D_H
#define LB_SMOOTHING_FUNCTIONALS_3D_H
 
#include "functors/lattice/reductionF3D.h"
 
namespace olb {
 
template<typename T>
struct LatticePosAndWeight {
  // Global IC
  int globic = 0;
  // Lattice position
  int latticePos[3] = {0, 0, 0};
  // Multiplicative weight for kernel smoothing
  T weight = T();
  // Continuous phase volume fraction
  T continuousPhaseFraction = 1.;
};
 
template<typename T, typename Lattice>
class SmoothingFunctional {
public:
  // Rebuilds _latticePosAndWeight with the new cells within _kernelLength from the bubble's position
  virtual bool update(T physPosP[], int globic);
  // Returns read-only access to internal data
  const std::deque<LatticePosAndWeight<T>> getData() const
  {
    return _latticePosAndWeight;
  }
  int getNvoxelInterpPoints()
  {
    return _nVoxelInterpPoints;
  }
protected:
  SmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice, int nVoxelInterpPoints=2 );
  virtual T smoothingFunction(T delta)=0;
  virtual T compute(T physPosP[], T physPosL[])=0;
  T _kernelLength; // Kernel's smoothing length.
  UnitConverter<T, Lattice>& _converter;  // reference to a UnitConverter
  SuperLattice<T, Lattice>& _sLattice; // reference to a lattice
  // positions and weights of the cells within _kernelLength from bubble's position
  std::deque<LatticePosAndWeight<T> > _latticePosAndWeight;
  int _nVoxelInterpPoints;
};
 
template<typename T, typename Lattice>
class LinearAveragingSmoothingFunctional : public SmoothingFunctional<T, Lattice> {
protected:
  LinearAveragingSmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice, int nVoxelInterpPoints=2 );
  virtual T compute(T physPosP[], T physPosL[]) override;
};
 
template<typename T, typename Lattice>
class VolumeAveragingSmoothingFunctional : public SmoothingFunctional<T, Lattice> {
protected:
  VolumeAveragingSmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice, int nVoxelInterpPoints=2 );
  virtual T compute(T physPosP[], T physPosL[]) override;
};
 
template<typename T, typename Lattice>
class DeenSmoothingFunctional : public LinearAveragingSmoothingFunctional<T, Lattice> {
public:
  DeenSmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice );
protected:
  virtual T smoothingFunction(T delta) override;
};
 
template<typename T, typename Lattice>
class vanWachemSmoothingFunctional : public LinearAveragingSmoothingFunctional<T, Lattice> {
public:
  vanWachemSmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice, T radius, int nVoxelInterpPoints );
  // Rebuilds _latticePosAndWeight with the new cells within _kernelLength from the bubble's position
  virtual bool update(T physPosP[], int globic) override;
protected:
  virtual T smoothingFunction(T delta) override;
  void updateContinuousPhaseFraction(T physPosP[], int globic);
  T _radius; // particle radius (I assume all the particles in the system have the same radius!)
};
 
template<typename T, typename Lattice>
class StepSmoothingFunctional : public VolumeAveragingSmoothingFunctional<T, Lattice> {
public:
  StepSmoothingFunctional (
    T kernelLength, UnitConverter<T, Lattice>& converter, SuperLattice<T, Lattice>& sLattice );
protected:
  virtual T smoothingFunction(T delta) override;
};
 
}
 
#endif