multiPhaseUnitConverter.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2017 Max Gaedtke, Albert Mink
 *  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 MULTIPHASEUNITCONVERTER_H
#define MULTIPHASEUNITCONVERTER_H
 
 
#include <math.h>
#include "io/ostreamManager.h"
#include "core/util.h"
#include "io/xmlReader.h"
#include "core/unitConverter.h"
 
// All OpenLB code is contained in this namespace.
namespace olb {
 
 
 
template <typename T, typename DESCRIPTOR>
class MultiPhaseUnitConverter : public UnitConverter<T, DESCRIPTOR> {
public:
  constexpr MultiPhaseUnitConverter(
    size_t resolution,
    T charPhysLength,
    T charPhysVelocity,
    T physViscosity,
    T physEoSa,
    T latticeEoSa,
    T physEoSb,
    T physMolarMass,
    T physSurfaceTension,
    T charPhysTemperature,
    T charPhysPressure )
    : UnitConverter<T, DESCRIPTOR>(
        (charPhysLength/resolution),
        (charPhysLength/resolution)*util::pow(physEoSa/latticeEoSa, -0.5)*util::pow(physEoSb*10.5/1., 0.5)*util::pow(physMolarMass*1, 0.5),
        charPhysLength,
        charPhysVelocity,
        physViscosity,
        physMolarMass*1/(physEoSb*10.5/1.),
        charPhysPressure),
      _conversionEoSa(physEoSa/latticeEoSa),
      _conversionEoSb(physEoSb*10.5/1.),
      _conversionMolarMass(physMolarMass*1),
      _conversionSurfaceTension(this->_conversionLength*_conversionEoSa*util::pow(_conversionEoSb, -2)),
      _conversionTemperature(_conversionEoSa/_conversionEoSb/_conversionGasConstant),
      _physEoSa(physEoSa),
      _physEoSb(physEoSb),
      _physMolarMass(physMolarMass),
      _physSurfaceTension(physSurfaceTension),
      _charPhysTemperature(charPhysTemperature),
      _latticeSurfaceTension( physSurfaceTension / _conversionSurfaceTension ),
      clout(std::cout,"MultiPhaseUnitConv")
  {
  };
 
  constexpr T getCharPhysTemperature(  ) const
  {
    return _charPhysTemperature;
  };
  constexpr T getPhysEoSa(  ) const
  {
    return _physEoSa;
  };
  constexpr T getPhysEoSb(  ) const
  {
    return _physEoSb;
  };
  constexpr T getPhysMolarMass(  ) const
  {
    return _physMolarMass;
  };
  constexpr T getPhysSurfaceTension(  ) const
  {
    return _physSurfaceTension;
  };
  constexpr T getPhysTemperature(  ) const
  {
    return _charPhysTemperature;
  };
 
  constexpr T getConversionFactorEoSa() const
  {
    return _conversionEoSa;
  };
 
  constexpr T getConversionFactorEoSb() const
  {
    return _conversionEoSb;
  };
 
  constexpr T getConversionFactorMolarMass() const
  {
    return _conversionMolarMass;
  };
 
  constexpr T getConversionFactorGasConstant() const
  {
    return _conversionGasConstant;
  };
 
  constexpr T getConversionFactorSurfaceTension() const
  {
    return _conversionSurfaceTension;
  };
 
  constexpr T getConversionFactorTemperature(  ) const
  {
    return _conversionTemperature;
  };
 
  constexpr T getLatticeSurfaceTension(  ) const
  {
    return _latticeSurfaceTension;
  };
 
  void print() const override;
 
 
 
protected:
  // conversion factors
  const T _conversionEoSa;                      // kg m^5 / s^2 mol^2
  const T _conversionEoSb;                      // m^3 / mol
  const T _conversionMolarMass;                 // kg / mol
  const T _conversionGasConstant = 8.314462618; // J / mol K = kg m^2 / s^2 mol K
  const T _conversionSurfaceTension;            // J / m^2 = kg / s^2
  const T _conversionTemperature;               // K
 
  // physical units, e.g characteristic or reference values
  const T _physEoSa;                            // kg m^5 / s^2 mol^2
  const T _physEoSb;                            // m^3 / mol
  const T _physMolarMass;                       // kg / mol
  const T _physSurfaceTension;                  // J / m^2 = kg / s^2
  const T _charPhysTemperature;                 // K
 
  // lattice units, discretization parameters
  const T _latticeSurfaceTension;               // -
 
private:
  mutable OstreamManager clout;
};
 
}  // namespace olb
 
#endif