add dfSteadyFoam

Allwmake

@@ -25,5 +25,6 @@ wmake applications/solvers/dfLowMachFoam
 wmake applications/solvers/dfHighSpeedFoam
 wmake applications/solvers/dfSprayFoam
 wmake applications/solvers/dfBuoyancyFoam
+wmake applications/solvers/dfSteadyFoam
 
 wmake applications/utilities/flameSpeed

applications/solvers/dfSteadyFoam/CMakeLists.txt

@@ -0,0 +1,122 @@
+cmake_minimum_required(VERSION 3.5)
+project(dfLowMachFoam LANGUAGES CXX)
+FIND_PACKAGE(MPI REQUIRED)
+FIND_PACKAGE(OpenMP REQUIRED)
+FIND_PACKAGE(CUDA REQUIRED)
+
+# Check valid thirdParty
+if(DEFINED ENV{WM_PROJECT_DIR})
+	MESSAGE(STATUS "OpenFOAM: " $ENV{WM_PROJECT_DIR})
+else()
+	message(FATAL_ERROR "OpenFOAM is not sourced")
+endif(DEFINED ENV{WM_PROJECT_DIR})
+
+if(DEFINED ENV{CANTERA_ROOT})
+	MESSAGE(STATUS "libcantera: " $ENV{CANTERA_ROOT})
+  SET(CANTERA_ROOT $ENV{CANTERA_ROOT})
+else()
+	message(FATAL_ERROR "libcantera directory is not specified")
+endif(DEFINED ENV{CANTERA_ROOT})
+
+# define variables
+SET(OpenFOAM_LIB_DIR $ENV{FOAM_LIBBIN})
+SET(OpenFOAM_SRC $ENV{FOAM_SRC})
+
+SET(DF_ROOT $ENV{DF_ROOT})
+SET(DF_SRC $ENV{DF_SRC})
+SET(SRC_ORIG $ENV{SRC_ORIG})
+
+# set compilation options
+SET(CMAKE_EXE_LINKER_FLAGS "-fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed")
+SET (CMAKE_C_FLAGS ${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS})
+SET (CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS})
+
+SET(CMAKE_C_COMPILER g++)
+SET(PATH_LIB_OPENMPI "openmpi-system")  # Foundation version
+SET(EXE_COMPILE_OPTION "-std=c++14 -m64 -Dlinux64 -DWM_ARCH_OPTION=64
+-DWM_DP -DWM_LABEL_SIZE=32 -Wall -Wextra -Wold-style-cast -Wnon-virtual-dtor
+-Wno-unused-parameter -Wno-invalid-offsetof -Wno-attributes -O3
+-DNoRepository -ftemplate-depth-100
+-Wno-unused-variable -Wno-unused-but-set-variable -Wno-old-style-cast -DOMPI_SKIP_MPICXX
+-pthread -fPIC")
+add_definitions("${EXE_COMPILE_OPTION}")
+
+# add header files
+FUNCTION(R_SEARCH search_path return_list)
+    FILE(GLOB_RECURSE new_list ${search_path}/*.H)
+    SET(dir_list "")
+    FOREACH(file_path ${new_list})
+        GET_FILENAME_COMPONENT(dir_path ${file_path} PATH)
+        SET(dir_list ${dir_list} ${dir_path})
+    ENDFOREACH()
+    LIST(REMOVE_DUPLICATES dir_list)
+    SET(${return_list} ${dir_list} PARENT_SCOPE)
+ENDFUNCTION(R_SEARCH)
+
+R_SEARCH(${DF_SRC}/dfCombustionModels dfcombustion_inc)
+R_SEARCH(${DF_SRC}/dfCanteraMixture dfcantera_inc)
+R_SEARCH(${DF_SRC}/lagrangian/intermediate dflagrangianinter_inc)
+R_SEARCH(${DF_SRC}/lagrangian/spray dflagrangianspray_inc)
+R_SEARCH(${DF_SRC}/lagrangian/turbulence dflagrangianturb_inc)
+R_SEARCH(${DF_SRC}/dfChemistryModel dfchemistry_inc)
+R_SEARCH(${DF_SRC}/thermophysicalModels/thermophysicalProperties dfthermophysicalprop_inc)
+R_SEARCH(${DF_SRC}/thermophysicalModels/thermophysicalProperties dfthermophysicalprop_inc)
+R_SEARCH(${DF_SRC}/thermophysicalModels/basic dfthermophysicalbasic_inc)
+R_SEARCH(${DF_SRC}/thermophysicalModels/SLGThermo dfthermophysicalslg_inc)
+R_SEARCH(${DF_SRC}/TurbulenceModels dfturbulence_inc)
+R_SEARCH(${DF_SRC}/dynamicMesh dfnewdynamic_inc)
+R_SEARCH(${DF_SRC}/dynamicFvMesh dffvdynamic_inc)
+
+include_directories(
+    ${OpenFOAM_SRC}/finiteVolume/lnInclude
+    ${OpenFOAM_SRC}/OSspecific/POSIX/lnInclude
+    ${OpenFOAM_SRC}/OpenFOAM/lnInclude
+    ${OpenFOAM_SRC}/transportModels/compressible/lnInclude
+    ${OpenFOAM_SRC}/thermophysicalModels/basic/lnInclude
+    ${OpenFOAM_SRC}/TurbulenceModels/turbulenceModels/lnInclude
+    ${OpenFOAM_SRC}/TurbulenceModels/compressible/lnInclude
+    ${OpenFOAM_SRC}/finiteVolume/cfdTools
+    ${OpenFOAM_SRC}/finiteVolume/lnInclude
+    ${OpenFOAM_SRC}/meshTools/lnInclude
+    ${OpenFOAM_SRC}/sampling/lnInclude
+    ${OpenFOAM_SRC}/dynamicFvMesh/lnInclude
+    ${OpenFOAM_SRC}/Pstream/mpi
+    ${dfcantera_inc}
+    ${dfchemistry_inc}
+    ${dfcombustion_inc}
+    ${CANTERA_ROOT}/include
+    ${MPI_INCLUDE_PATH}
+    ${PROJECT_SOURCE_DIR}
+    ${CUDA_INCLUDE_DIRS}
+    /home/runze/AmgX/AMGX/include
+    /home/runze/deepflame-dev/src_gpu
+)
+
+# add execution
+add_executable(${PROJECT_NAME} ${PROJECT_SOURCE_DIR}/dfLowMachFoam.C)
+
+target_link_libraries(${PROJECT_NAME}
+    $ENV{FOAM_LIBBIN}/libfiniteVolume.so libmeshTools.so libcompressibleTransportModels.so
+    libturbulenceModels.so libsampling.so libOpenFOAM.so
+    ${CANTERA_ROOT}/lib/libcantera_shared.so.2
+    ${DF_ROOT}/lib/libdfChemistryModel.so
+    ${DF_ROOT}/lib/libdfCanteraMixture.so
+    ${DF_ROOT}/lib/libdfFluidThermophysicalModels.so
+    ${DF_ROOT}/lib/libdfCombustionModels.so
+    $ENV{FOAM_LIBBIN}/openmpi-system/libPstream.so
+    ${MPI_LIBRARIES}
+    ${CUDA_LIBRARIES}
+    /home/runze/AmgX/AMGX/build/libamgxsh.so
+    /home/runze/deepflame-dev/src_gpu/build/libdfMatrix.so
+)
+
+if(DEFINED ENV{PYTHON_INC_DIR})
+  add_definitions(-DUSE_PYTORCH)
+  # https://pybind11.readthedocs.io/en/stable/advanced/embedding.html
+  find_package(pybind11)
+  target_link_libraries(${PROJECT_NAME} pybind11::embed)
+endif()
+
+# install
+set(CMAKE_INSTALL_PREFIX ${DF_ROOT})
+install(TARGETS ${PROJECT_NAME} DESTINATION bin)

applications/solvers/dfSteadyFoam/EEqn.H

@@ -0,0 +1,27 @@
+{
+    volScalarField& he = thermo.he();
+
+    fvScalarMatrix EEqn
+    (
+
+         fvm::div(phi, he)
+      + (
+            he.name() == "e"
+          ? fvc::div(phi, volScalarField("Ekp", 0.5*magSqr(U) + p/rho))
+          : fvc::div(phi, volScalarField("K", 0.5*magSqr(U)))
+        )
+      - fvm::laplacian(turbulence->alphaEff(), he)
+     ==
+          combustion->Qdot()
+        + fvOptions(rho, he)
+    );
+
+    EEqn.relax();
+
+    fvOptions.constrain(EEqn);
+
+    EEqn.solve("hs");
+    // EEqn.solve("ha");
+
+    fvOptions.correct(he);
+}

applications/solvers/dfSteadyFoam/Make/files

@@ -0,0 +1,3 @@
+dfSteadyFoam.C
+
+EXE = $(DF_APPBIN)/dfSteadyFoam

applications/solvers/dfSteadyFoam/Make/options

@@ -0,0 +1,82 @@
+-include $(GENERAL_RULES)/mplibType
+
+EXE_INC = -std=c++14 \
+    -g \
+    -fopenmp \
+    -Wno-unused-variable \
+    -Wno-unused-but-set-variable \
+    -Wno-old-style-cast \
+    -I. \
+    $(PFLAGS) $(PINC) \
+    $(if $(LIBTORCH_ROOT),-DUSE_LIBTORCH,) \
+    $(if $(PYTHON_INC_DIR),-DUSE_PYTORCH,) \
+    -I$(FOAM_APP)/solvers/lagrangian/reactingParcelFoam \
+    -I$(FOAM_APP)/solvers/compressible/rhoSimpleFoam \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(FOAM_APP)/solvers/lagrangian/reactingParcelFoam \
+    -I$(LIB_SRC)/finiteVolume/cfdTools \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+    -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(DF_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(DF_SRC)/lagrangian/spray/lnInclude \
+    -I$(LIB_SRC)/lagrangian/spray/lnInclude \
+    -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
+    -I$(DF_SRC)/thermophysicalModels/thermophysicalProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/thermophysicalProperties/lnInclude \
+    -I$(DF_SRC)/thermophysicalModels/SLGThermo/lnInclude \
+    -I$(LIB_SRC)/Pstream/mpi \
+    -I$(DF_SRC)/dfCanteraMixture/lnInclude \
+    -I$(DF_SRC)/dfChemistryModel/lnInclude \
+    -I$(DF_SRC)/dfCombustionModels/lnInclude \
+    -I$(CANTERA_ROOT)/include \
+    $(if $(LIBTORCH_ROOT),-I$(LIBTORCH_ROOT)/include,) \
+    $(if $(LIBTORCH_ROOT),-I$(LIBTORCH_ROOT)/include/torch/csrc/api/include,) \
+    $(PYTHON_INC_DIR) \
+    $(if $(AMGX_DIR), -I$(DF_ROOT)/src_gpu,) \
+    $(if $(AMGX_DIR), -I/usr/local/cuda/include,) \
+    $(if $(AMGX_DIR), -I$(AMGX_DIR)/include,) \
+    $(if $(ODE_GPU_SOLVER), -I$(OPENCC_PATH)/include,) \
+    $(if $(ODE_GPU_SOLVER), -DODE_GPU_SOLVER,)
+
+EXE_LIBS = \
+    -lcompressibleTransportModels \
+    -lturbulenceModels \
+    -llagrangian \
+    -lregionModels \
+    -ldfSurfaceFilmModels \
+    -lfiniteVolume \
+    -ltopoChangerFvMesh \
+    -lmeshTools \
+    -lsampling \
+    -L$(DF_LIBBIN) \
+    -ldfFluidThermophysicalModels \
+    -ldfCompressibleTurbulenceModels \
+    -ldfThermophysicalProperties \
+    -ldfSLGThermo \
+    -ldfLagrangianIntermediate \
+    -ldfLagrangianTurbulence \
+    -ldfLagrangianSpray \
+    -ldfCanteraMixture \
+    -ldfChemistryModel \
+    -ldfCombustionModels  \
+    $(CANTERA_ROOT)/lib/libcantera.so \
+    $(if $(LIBTORCH_ROOT),$(LIBTORCH_ROOT)/lib/libtorch.so,) \
+    $(if $(LIBTORCH_ROOT),$(LIBTORCH_ROOT)/lib/libc10.so,) \
+    $(if $(LIBTORCH_ROOT),-rdynamic,) \
+    $(if $(LIBTORCH_ROOT),-lpthread,) \
+    $(if $(LIBTORCH_ROOT),$(DF_SRC)/dfChemistryModel/DNNInferencer/build/libDNNInferencer.so,) \
+    $(if $(PYTHON_LIB_DIR),$(PYTHON_LIB_DIR),) \
+    $(if $(AMGX_DIR), /usr/local/cuda/lib64/libcudart.so,) \
+	$(if $(AMGX_DIR), /usr/local/cuda/lib64/libnccl.so,) \
+    $(if $(AMGX_DIR), $(DF_ROOT)/src_gpu/build/libdfMatrix.so,) \
+    $(if $(AMGX_DIR), $(AMGX_DIR)/build/libamgxsh.so,) \
+    $(if $(ODE_GPU_SOLVER), $(ODE_GPU_SOLVER)/lib/libopencc.so,)

applications/solvers/dfSteadyFoam/UEqn.H

@@ -0,0 +1,24 @@
+// Solve the Momentum equation
+
+    MRF.correctBoundaryVelocity(U);
+
+    tmp<fvVectorMatrix> tUEqn
+    (
+          fvm::div(phi, U)
+      +   MRF.DDt(rho, U)
+      +   turbulence->divDevRhoReff(U)
+    ==
+        fvOptions(rho, U)
+    );
+    fvVectorMatrix& UEqn = tUEqn.ref();
+
+    UEqn.relax();
+
+    fvOptions.constrain(UEqn);
+
+    solve(UEqn == -fvc::grad(p));
+
+    fvOptions.correct(U);
+
+
+

applications/solvers/dfSteadyFoam/YEqn.H

@@ -0,0 +1,59 @@
+     // should only for CPUSolver
+
+    tmp<fv::convectionScheme<scalar>> mvConvection
+    (
+        fv::convectionScheme<scalar>::New
+        (
+            mesh,
+            fields,
+            phi,
+            mesh.divScheme("div(phi,Yi_h)")
+        )
+    );
+
+
+    label flag_mpi_init;
+    MPI_Initialized(&flag_mpi_init);
+    if(flag_mpi_init) MPI_Barrier(PstreamGlobals::MPI_COMM_FOAM);
+
+    {
+
+    combustion->correct();
+
+    //label flag_mpi_init;
+    //MPI_Initialized(&flag_mpi_init);
+    if(flag_mpi_init) MPI_Barrier(PstreamGlobals::MPI_COMM_FOAM);
+
+
+    volScalarField Yt(0.0*Y[0]);
+    forAll(Y, i)
+    {
+        if (i != inertIndex)
+        {
+            volScalarField& Yi = Y[i];
+
+            fvScalarMatrix YiEqn
+            (
+                mvConvection->fvmDiv(phi, Yi)
+              - fvm::laplacian(turbulence->muEff(), Yi)
+             ==
+                combustion->R(Yi)
+              + fvOptions(rho, Yi)
+            );
+
+            YiEqn.relax();
+
+            fvOptions.constrain(YiEqn);
+
+            YiEqn.solve("Yi");
+
+            fvOptions.correct(Yi);
+
+            Yi.max(0.0);
+            Yt += Yi;
+        }
+    }
+
+    Y[inertIndex] = scalar(1) - Yt;
+    Y[inertIndex].max(0.0);
+}