ParametersConversion.h

Go to the documentation of this file.

// ==============================================================================================
// Microflow 3D, http://www.microflow.pwr.edu.pl/
// Created by Roman Szafran on 18.05.19.
// Copyright (c) 2019 Wroclaw University of Science and Technology.
// Distributed under the Apache License, Version 2.0. You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0 or see accompanying file license.txt.
// Redistributions of source code must retain the above copyright and license notice.
// ==============================================================================================

# pragma once

// OpenVDB
#include <openvdb/openvdb.h>

#include "MFSolver_CPU/CaseParameters.h"
#include "GridUtilities/LatticeParametersD3Q19.h"
#include "MFDatabase/Vec3.h"

namespace MF {
    namespace LBPC {

        class ParametersConversion {
        public:

            ParametersConversion() = default;

            ~ParametersConversion() = default;

            static void Initialize (const std::shared_ptr<MF::Database::ConfigData>& ConfigData_Ptr, const std::shared_ptr<MF::GU::LatticeParametersD3Q19>& LatticeParameters_Ptr) {

                u_ch_phys = ConfigData_Ptr->getCaseFloatParam("CharactersticParams.CharactVelocityPhysical_U_CH_Phys");
                l_ch_phys = ConfigData_Ptr->getCaseFloatParam("CharactersticParams.CharactLengthPhysical_L_CH_Phys");
                nu_phys = ConfigData_Ptr->getCaseFloatParam("PhysicalParams.FluidPhysicalViscosity_Nu_Phys");
                dx_phys = ConfigData_Ptr->getCaseFloatParam("GeometryParams.PhysicalVoxelSize");
                TAU = ConfigData_Ptr->getCaseFloatParam("PhysicalParams.Tau");
                csq = LatticeParameters_Ptr->LatticeConstant_CSQ;
                rho0_LB = ConfigData_Ptr->getCaseFloatParam("InitialCondition.ReferenceDensityLB_Rho0_LB");
                rho0_phys = ConfigData_Ptr->getCaseFloatParam("PhysicalParams.FluidPhysicalReferenceDensity_Rho0_Phys");
                FluidFlowModel_MT = ConfigData_Ptr->getFlowType();
            };

        private:
            static double Re; 
            static double l_ch_LB; 
            static double u_ch_LB; 
            static double dt_phys; 
            static double nu_LB; 
            static double Cu; 
            static double TAU, csq, rho0_LB, rho0_phys, u_ch_phys, l_ch_phys, nu_phys, dx_phys;
            static int FluidFlowModel_MT; 

        public:
            static void ComputeBasicParameters(const std::shared_ptr<MF::Solver_CPU::CaseParameters>& CaseParameters_Ptr,const openvdb::Int64Grid::Ptr& VDBGrid_Ptr);

            static inline double ULB_toPhys(double u_LB)
            {
                return ((u_LB * l_ch_LB * nu_phys) / (nu_LB * l_ch_phys));
            };

            static inline MF::Database::Vec3<double> ULB_toPhys(MF::Database::Vec3<double> u_LB) {
                MF::Database::Vec3<double> u_phys;
                u_phys.x = (u_LB.x * l_ch_LB * nu_phys) / (nu_LB * l_ch_phys);
                u_phys.y = (u_LB.y * l_ch_LB * nu_phys) / (nu_LB * l_ch_phys);
                u_phys.z = (u_LB.z * l_ch_LB * nu_phys) / (nu_LB * l_ch_phys);
                return u_phys;
            };

            static inline double UPhys_toLB(double u_phys)
            {
                return ((u_phys * l_ch_phys * nu_LB) / (nu_phys * l_ch_LB));
            };

            static inline MF::Database::Vec3<double> UPhys_toLB(MF::Database::Vec3<double> u_phys) {
                MF::Database::Vec3<double> u_LB;
                u_LB.x = (u_phys.x * l_ch_phys * nu_LB) / (nu_phys * l_ch_LB);
                u_LB.y = (u_phys.y * l_ch_phys * nu_LB) / (nu_phys * l_ch_LB);
                u_LB.z = (u_phys.z * l_ch_phys * nu_LB) / (nu_phys * l_ch_LB);
                return u_LB;
            }

            static inline double RhoLB_toPressurePhys(double rho_LB)
            {
                return (csq * (rho_LB - rho0_LB) * rho0_phys / rho0_LB * ((dx_phys * dx_phys) / (dt_phys * dt_phys)));
            };

            static inline double PressurePhys_toRhoLB(double p_phys)
            {
                return (rho0_LB + ((p_phys * rho0_LB) / (rho0_phys * csq)) * ((dt_phys * dt_phys) / (dx_phys * dx_phys)));
            };

            static inline double RhoLB_toRhoPhys(double rho_LB)
            {
                double RhoPhys = 0;
                if(FluidFlowModel_MT == 1) // Incompressible
                    RhoPhys = rho0_phys;
                else
                    RhoPhys = rho0_phys / rho0_LB * rho_LB;
                return (RhoPhys);
            };

            static inline double RhoPhys_toRhoLB(double rho_phys)
            {
                return (rho_phys * rho0_LB / rho0_phys);
            };

            static inline double FPhys_toFLB(double F_phys)
            {
                return (F_phys / (rho0_phys / rho0_LB * dx_phys / (dt_phys * dt_phys)));
            }

            static inline MF::Database::Vec3<double> FPhys_toFLB(MF::Database::Vec3<double> F_phys)
            {
                MF::Database::Vec3<double> FLB;
                FLB.x = F_phys.x / (rho0_phys / rho0_LB * dx_phys / (dt_phys * dt_phys));
                FLB.y = F_phys.y / (rho0_phys / rho0_LB * dx_phys / (dt_phys * dt_phys));
                FLB.z = F_phys.z / (rho0_phys / rho0_LB * dx_phys / (dt_phys * dt_phys));
                return (FLB);
            }

            static inline double FLB_toFPhys(double F_LB)
            {
                return (F_LB * rho0_phys / rho0_LB * dx_phys / (dt_phys * dt_phys));
            };
        };


    } /* namespace LBPC */
} /* namespace MF */