MFSolver_CPU.cpp

Go to the documentation of this file.

// ==============================================================================================
// Microflow 3D, http://www.microflow.pwr.edu.pl/
// Created by Roman Szafran on 02.03.19.
// Modified by Roman Szafran, last on 11.10.2020.
// Copyright (c) 2020 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.
// ==============================================================================================

// System
#include <iostream>
#include <memory>
#include <chrono>

// MF
#include "ConsoleWriter.h"
#include "CmdLineArgsParser.h"
#include "ConfigData.h"
#include "ProgramParameters.h"
#include "CaseParameters.h"
#include "GeometryBuildFromSTL.h"
#include "AutoThreading.h"
#include "ThreadArray.h"
#include "BoundaryFunctions.h"
#include "FluidFunctions.h"
#include "Collision.h"
#include "Initialization.h"
#include "ParametersConversion.h"

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

//-------------------------------------------------------------------------------------------------------------
// Use for Development
// #define defaultPathToProgramConfigFile "../../Config/Microflow.cfg"
// Use for Release
#define defaultPathToProgramConfigFile "Config/Microflow.cfg" 
#define defaultScope "MF01" 
//-------------------------------------------------------------------------------------------------------------

int main(int argc, char** argv) {

    const char* pPathToProgramConfigFile = defaultPathToProgramConfigFile;
    // Use for Development
    // const char*  pPathToCaseFolder = "../../Data/Validation_tests/Case_MEDIUM_straight_square_channel";
    // Use for Release
    const char* pPathToCaseFolder = "Data/Validation_tests/Case_MEDIUM_straight_square_channel";
    const char* pPathToCaseFile = "";
    const char* pPathToThreadFile = "";
    const char* pScope = defaultScope;  // Scope of parameters appropriate for this solver
    std::string tempString;
    bool verbose = false;               // Verbose mode
    bool geometryOnly = false;          // Only geometry generation and grid voxelization mode
    auto exitStatus = 0;
    auto CPU_ThreadsNr = 0;


    // Microflow 3D let's start!
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;
    cout << "Microflow 3D v1.0 " << endl;
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "Microflow framework >>> Initialization info:" << endl;

    // Initialize openvdb library.
    openvdb::initialize();

    // Command line parameters parsing
    auto CmdLineArgsParser_Ptr = MF::Parser::CmdLineArgsParser::New();
    CmdLineArgsParser_Ptr->parseCmdLineArgs(argc, argv, pPathToProgramConfigFile, pPathToCaseFolder, pScope, verbose, geometryOnly, CPU_ThreadsNr); // Command line processing

    // Parsing solver, case and thread config files
    auto ConfigData_Ptr = MF::Database::ConfigData::New(pPathToProgramConfigFile, pPathToCaseFolder, pScope, verbose);

    // End of Microflow framework initialization
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "Microflow framework >>> Geometry building info: " << endl;

    auto LatticeParameters_Ptr = MF::GU::LatticeParametersD3Q19::New();
    auto Geometry_Ptr = MF::GB::GeometryBuildFromSTL::New(ConfigData_Ptr,LatticeParameters_Ptr);
    Geometry_Ptr->ReadGrid(verbose);
    Geometry_Ptr->AutomaticBoundaryFind();
    if (geometryOnly) {
        Geometry_Ptr->WriteGeometryGridToVtiFile();
        Geometry_Ptr->WriteGeometryGridToVDBFile();
        cout << endl;
        cout << "----------------------------------------------------------------------------------" << endl;
        cout << "Geometry file has been generated ***** Goodbye *****" << endl;
        cout << "----------------------------------------------------------------------------------" << endl;
        exit(0);
    }
    Geometry_Ptr->FluidAddFromThreadFile();
    Geometry_Ptr->SolidAddFromThreadFile();
    Geometry_Ptr->BoundaryAddFromThreadFile();
    Geometry_Ptr->Clean();

    // End of Microflow framework geometry building
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "MFSolver_CPU >>> Case and program parameters initialization info: " << endl;

    // Program parameters initialization
    auto ProgramParameters_Ptr = MF::Solver_CPU::ProgramParameters::New(ConfigData_Ptr);    //Initialization of program parameters from parser object data

    // Case parameters initialisation
    auto CaseParameters_Ptr = MF::Solver_CPU::CaseParameters::New(ConfigData_Ptr); //Initialization of case parameters from parser object data

    // Set up number of CPU threads to allocate computations
    if (CPU_ThreadsNr == 0 && CaseParameters_Ptr->CPU_ThreadsNr == 0)
        CPU_ThreadsNr = omp_get_num_procs();
    else if (CPU_ThreadsNr == 0 && CaseParameters_Ptr->CPU_ThreadsNr != 0)
        CPU_ThreadsNr = CaseParameters_Ptr->CPU_ThreadsNr;

    // End of case and program parameters initialisation
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "MFDatabase >>> Threads building info: " << endl;

    auto ThreadArray_Ptr = MF::Database::ThreadArray::New(LatticeParameters_Ptr);
    MF::Database::AutoThreading::ThreadPartitioning(Geometry_Ptr->m_VDBInt64GeometryGrid_Ptr, ConfigData_Ptr);
    MF::Database::AutoThreading::GridThreading(Geometry_Ptr->m_VDBInt64GeometryGrid_Ptr, ThreadArray_Ptr);

    // End of threads building
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "MFSolver_CPU >>> Threads data initialization info: " << endl;

    MF::Solver_CPU::BoundaryFunctions::Initialize(CaseParameters_Ptr,LatticeParameters_Ptr);
    MF::Solver_CPU::BoundaryFunctions::SetBoundaryNodePointerToFunc(ThreadArray_Ptr);
    MF::Solver_CPU::FluidFunctions::Initialize(CaseParameters_Ptr,LatticeParameters_Ptr);
    MF::Solver_CPU::FluidFunctions::SetFluidSolidNodePointerToFunc(ThreadArray_Ptr);
    MF::Solver_CPU::Collision::Initialize(CaseParameters_Ptr,LatticeParameters_Ptr);
    MF::Solver_CPU::Collision::SetCollisionPointerToFunc(ThreadArray_Ptr);

    // Initialisation of calculations
    MF::LBPC::ParametersConversion::Initialize(ConfigData_Ptr,LatticeParameters_Ptr);
    MF::LBPC::ParametersConversion::ComputeBasicParameters(CaseParameters_Ptr,Geometry_Ptr->m_VDBInt64GeometryGrid_Ptr);
    MF::Solver_CPU::Initialization::ThreadDefaultDataInitialize(ThreadArray_Ptr,CaseParameters_Ptr);
    MF::Solver_CPU::Initialization::ThreadDataInitialize(ThreadArray_Ptr,ConfigData_Ptr);
    MF::Solver_CPU::Initialization::EquilibriumInitialization(ThreadArray_Ptr,CaseParameters_Ptr);

    // Prints on console extended info
    if(verbose) {
        // MF::Solver_CPU::ConsoleWriter::ExtendedInfo(ProgramParameters_Ptr, CaseParameters_Ptr, ConfigData_Ptr);
        // MF::Solver_CPU::ConsoleWriter::ThreadsNodeInfo(ThreadArray_Ptr);
        MF::Solver_CPU::ConsoleWriter::ThreadsArrayInfo(ThreadArray_Ptr);
    }

    // End of threads data initialisation
    cout << "----------------------------------------------------------------------------------------------------------------------------" << endl;

    cout << "MFSolver_CPU >>> Main loop info: " << endl;

    // Calculation order compatible with a GPU code: pre-collision | propagation -> boundary conditions -> collision
    unsigned int SimStep = 0;
    double V_SimError;  
    double M_SimError;  
    std::string DataFileName;
    const unsigned int ConsoleWriteStep = CaseParameters_Ptr->ConsoleWriteStep_K_W;
    const unsigned int FileWriteStep = CaseParameters_Ptr->VTKWriteStep_VTK_W;
    const unsigned int VTKFileMaxNumber = CaseParameters_Ptr->VTKFileMaxNumber_VTK_Max;

    // Console info print
    MF::Solver_CPU::ConsoleWriter::PrintComputationParameters(CaseParameters_Ptr);
    MF::Solver_CPU::ConsoleWriter::PrintGridStatistics(ThreadArray_Ptr);
    MF::Solver_CPU::ConsoleWriter::PrintCPUInfo(CPU_ThreadsNr);

    // Before first step
    for (auto & Thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
        if (Thread->m_DoPreCollision && Thread->m_DoCollision) {
            Thread->DoPreANDCollision(CPU_ThreadsNr);
        }
        else if (Thread->m_DoCollision) {
            Thread->DoCollisionOnly(CPU_ThreadsNr);
        }
        else if (Thread->m_DoPreCollision) {
            Thread->DoPreCollisionOnly(CPU_ThreadsNr);
        }
    }

    // Initial data distributions save
    DataFileName = (ConfigData_Ptr->CaseFolder + ConfigData_Ptr->getProgramStringParam("OutputFile") + std::to_string(SimStep));
    Geometry_Ptr->m_MFGrid_GeometryGrid_Ptr->saveAllDataToVTIFile(ThreadArray_Ptr, ConfigData_Ptr, DataFileName);
    std::cout << std::endl;

    // Print initial statistics for 0 step
    MF::Solver_CPU::ConsoleWriter::PrintTimeStepStatistics(V_SimError, M_SimError, SimStep, ThreadArray_Ptr, CaseParameters_Ptr);

    // Main loop
    std::chrono::time_point<std::chrono::high_resolution_clock> TimeStart = std::chrono::high_resolution_clock::now();  // Starts time measuring.
    MF::Solver_CPU::ConsoleWriter::m_TimePreviousStep = TimeStart;
    V_SimError = CaseParameters_Ptr->Sc_VelocityResidueError_ErrV + 1; // Initialisation
    M_SimError = M_SimError > CaseParameters_Ptr->MassFlowError_ErrM + 1; // Initialisation

    while ((V_SimError > CaseParameters_Ptr->Sc_VelocityResidueError_ErrV) || (M_SimError > CaseParameters_Ptr->MassFlowError_ErrM)) {
        SimStep++;
        for (auto & Thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr)
            if (Thread->m_DoPropagation)
                Thread->DoPropagation(CPU_ThreadsNr);

        if (SimStep % ConsoleWriteStep == 0)
            MF::Solver_CPU::ConsoleWriter::PrintTimeStepStatistics(V_SimError, M_SimError, SimStep, ThreadArray_Ptr, CaseParameters_Ptr); // Prints info on console and calculates simulation error.

        if (FileWriteStep != 0 && SimStep % FileWriteStep == 0){
            cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;
            if(VTKFileMaxNumber > 0 && SimStep / FileWriteStep > VTKFileMaxNumber) {
                std::string ErraseFileName = (ConfigData_Ptr->CaseFolder + ConfigData_Ptr->getProgramStringParam("OutputFile") +
                                              std::to_string(SimStep - VTKFileMaxNumber * FileWriteStep) + ".vti");
                cout<<"Errased file: ----> "<<ErraseFileName<<endl;
                remove(ErraseFileName.c_str()); // Erase an old file.
            }
            DataFileName = (ConfigData_Ptr->CaseFolder + ConfigData_Ptr->getProgramStringParam("OutputFile") + std::to_string(SimStep));
            Geometry_Ptr->m_MFGrid_GeometryGrid_Ptr->saveAllDataToVTIFile(ThreadArray_Ptr, ConfigData_Ptr, DataFileName); // Save data to .vti file.
            cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;
        }

        for (auto &Thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
            if (Thread->m_DoPreCollision && Thread->m_DoCollision)
                Thread->DoPreANDCollision(CPU_ThreadsNr);
            else if (Thread->m_DoCollision)
                Thread->DoCollisionOnly(CPU_ThreadsNr);
            else if (Thread->m_DoPreCollision)
                Thread->DoPreCollisionOnly(CPU_ThreadsNr);
        }

    }

    // Final propagation - necessary for final f_post swap after last collision.
    for (auto & Thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr)
        Thread->DoPropagation(CPU_ThreadsNr);

    // End of main loop --------------------------------------------------------------------------------------------------------------------------------

    auto TimeStop = std::chrono::high_resolution_clock::now();  // Stop time measuring

    // Final results save
    cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;
    DataFileName = (ConfigData_Ptr->CaseFolder + ConfigData_Ptr->getProgramStringParam("OutputFile") + std::to_string(SimStep));
    Geometry_Ptr->m_MFGrid_GeometryGrid_Ptr->saveAllDataToVTIFile(ThreadArray_Ptr, ConfigData_Ptr, DataFileName);
    cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;

    // Computations statistics
    MF::Solver_CPU::ConsoleWriter::PrintComputationStatistics(TimeStart, TimeStop, SimStep, ThreadArray_Ptr);

    // End of postprocessing block----------------------------------------------------------------------------------------------------------------------

    cout << endl;
    cout << "----------------------------------------------------------------------------------" << endl;
    cout << "Microflow 3D ***** Goodbye *****" << endl;
    cout << "----------------------------------------------------------------------------------" << endl;

    return exitStatus;
}