powerLawUnitConverter.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2017-2018 Max Gaedtke, Albert Mink, 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.
*/
 
#ifndef PL_UNITCONVERTER_H
#define PL_UNITCONVERTER_H
 
 
#include <math.h>
#include "io/ostreamManager.h"
#include "core/util.h"
#include "io/xmlReader.h"
#include "unitConverter.h"
 
 
// All OpenLB code is contained in this namespace.
namespace olb {
 
 
 
template <typename T, typename DESCRIPTOR>
class PowerLawUnitConverter : public UnitConverter<T, DESCRIPTOR> {
public:
  constexpr PowerLawUnitConverter( T physDeltaX, T physDeltaT, T charPhysLength,
                                   T charPhysVelocity, T physConsistencyCoeff, T powerLawIndex,
                                   T physDensity, T charPhysPressure = 0 )
    : UnitConverter<T, DESCRIPTOR>( physDeltaX, physDeltaT, charPhysLength, charPhysVelocity,
                                    physConsistencyCoeff * util::pow(charPhysVelocity / (2*charPhysLength), powerLawIndex-1),
                                    physDensity, charPhysPressure ),
      _conversionConsistencyCoeff(util::pow( physDeltaT,powerLawIndex-2 ) * util::pow( physDeltaX,2 ) ),
      _powerLawIndex(powerLawIndex),
      _physConsistencyCoeff(physConsistencyCoeff),
      clout(std::cout,"PowerLawUnitConverter")
  {
  }
 
  constexpr T getReynoldsNumber(  ) const
  {
    // Calculation according to Metzner and Reed (1955): 10.1002/aic.690010409
    return util::pow(this->_charPhysVelocity, T{2} - _powerLawIndex) * util::pow(this->_charPhysLength, _powerLawIndex)
      / _physConsistencyCoeff;
  }
 
  constexpr T getPhysConsistencyCoeff( ) const
  {
    return _physConsistencyCoeff;
  }
  constexpr T getPhysConsistencyCoeff( T latticeConsistencyCoeff ) const
  {
    return _conversionConsistencyCoeff * latticeConsistencyCoeff;
  }
  constexpr T getLatticeConsistencyCoeff(  ) const
  {
    return _physConsistencyCoeff / _conversionConsistencyCoeff;
  }
  constexpr T getConversionFactorConsistencyCoeff() const
  {
    return _conversionConsistencyCoeff;
  }
 
  constexpr T getPowerLawIndex() const
  {
    return _powerLawIndex;
  }
 
  void print() const override;
  void print(std::ostream& fout) const override;
 
  void write(std::string const& fileName = "unitConverter") const override;
 
protected:
  // conversion factors
  const T _conversionConsistencyCoeff;         // m^2 s^(n-2)
 
  // physical units, e.g characteristic or reference values
  const T _powerLawIndex;
  const T _physConsistencyCoeff;         // m^2 s^(n-2)
 
private:
  mutable OstreamManager clout;
};
 
template <typename T, typename DESCRIPTOR>
PowerLawUnitConverter<T, DESCRIPTOR>* createPowerLawUnitConverter(XMLreader const& params);
 
template <typename T, typename DESCRIPTOR>
class PowerLawUnitConverterFrom_Resolution_RelaxationTime_Reynolds_PLindex : public PowerLawUnitConverter<T, DESCRIPTOR> {
public:
  constexpr PowerLawUnitConverterFrom_Resolution_RelaxationTime_Reynolds_PLindex(
    int resolution,
    T latticeRelaxationTime,
    T charPhysLength,
    T charPhysVelocity,
    T Re,
    T powerLawIndex,
    T physDensity,
    T charPhysPressure = 0)
    : PowerLawUnitConverter<T, DESCRIPTOR>( (charPhysLength/resolution),
                                            (latticeRelaxationTime - 0.5) / descriptors::invCs2<T,DESCRIPTOR>() * util::pow((charPhysLength/resolution),2) / ( ( charPhysLength * charPhysVelocity * util::pow( charPhysVelocity / ( 2 * charPhysLength ), 1 - powerLawIndex ) / Re ) * util::pow( charPhysVelocity / (2 * charPhysLength ), powerLawIndex - 1 ) ),
                                            charPhysLength, charPhysVelocity,
                                            charPhysLength * charPhysVelocity * util::pow( charPhysVelocity / ( 2 * charPhysLength ), 1 - powerLawIndex ) / Re, powerLawIndex, physDensity, charPhysPressure )
  {
  }
 
};
 
}  // namespace olb
 
#endif