ConsoleWriter.cpp

Go to the documentation of this file.

// ==============================================================================================
// Microflow 3D, http://www.microflow.pwr.edu.pl/
// Created by Roman Szafran on 25.03.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.
// ==============================================================================================

#include "ConsoleWriter.h"

// static variables initialisation
double MF::Solver_CPU::ConsoleWriter::m_VSum = 1;
unsigned int MF::Solver_CPU::ConsoleWriter::m_SimPreviousStep = 0;
double MF::Solver_CPU::ConsoleWriter::m_minMLUPS = 0;
double MF::Solver_CPU::ConsoleWriter::m_maxMLUPS = 0;
unsigned int MF::Solver_CPU::ConsoleWriter::m_iter = 0;
std::chrono::time_point<std::chrono::high_resolution_clock> MF::Solver_CPU::ConsoleWriter::m_TimePreviousStep;


int MF::Solver_CPU::ConsoleWriter::parseFileLine(char* line){
    // This assumes that a digit will be found and the line ends in " Kb".
    int i = strlen(line);
    const char* p = line;
    while (*p <'0' || *p > '9') p++;
    line[i-3] = '\0';
    i = atoi(p);
    return i;
}

int MF::Solver_CPU::ConsoleWriter::getMemoryUsageValue(){ //Note: this value is in KB!
    FILE* file = fopen("/proc/self/status", "r");
    int result = -1;
    char line[128];

    while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmRSS:", 6) == 0){
            result = parseFileLine(line);
            break;
        }
    }
    fclose(file);
    return result;
}

void MF::Solver_CPU::ConsoleWriter::PrintComputationStatistics(const std::chrono::time_point<std::chrono::high_resolution_clock> TimeStart, const std::chrono::time_point<std::chrono::high_resolution_clock> TimeStop, const unsigned int SimStep, const std::shared_ptr<MF::Database::ThreadArray>& ThreadArray_Ptr) {

    double cpu_time = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1> >> (TimeStop - TimeStart).count();
    double MLUPS = SimStep * MF::Solver_CPU::Calculations::getTotalNodeNumber(ThreadArray_Ptr) / cpu_time / 1e6;
    std::cout << "\n" << "Solver statistics : " << std::endl;
    std::cout.unsetf(std::ios::scientific);
    std::cout << "Computation time [s] = " << std::setw(15) << cpu_time << "mean MLUPS = " << std::setw(15) << MLUPS << "min MLUPS = " << std::setw(15) << m_minMLUPS << "max MLUPS = " << std::setw(15) << m_maxMLUPS << "Average memory usage [kB] = " << MF::Solver_CPU::ConsoleWriter::getMemoryUsageValue() << "\n" << std::endl;

}

void MF::Solver_CPU::ConsoleWriter::PrintCPUInfo(const int &CPU_ThreadsNr) {
    std::cout << "\n" << "CPU info: " << std::endl;
    std::cout << "Maximum number of available threads = " << omp_get_max_threads() << std::endl;
    std::cout << "Maximum number of available processor cores (including virtual) = " << omp_get_num_procs() << std::endl;
    std::cout << "Number of CPU threads allocated for solver = " << CPU_ThreadsNr << "\n" << std::endl;
}

void MF::Solver_CPU::ConsoleWriter::PrintComputationParameters(const std::shared_ptr<MF::Solver_CPU::CaseParameters>& CaseParameters_Ptr) {

    std::cout <<  std::endl;
    std::cout << "Re = " << CaseParameters_Ptr->ReynoldsNumber_Re << std::endl;
    std::cout << "U_Ch_LB = " << CaseParameters_Ptr->CharacteristicVelocityLBu_U_Ch_LB << std::endl;
    std::cout << "Dt_phys [s] = " << CaseParameters_Ptr->DTPhysical_Dt_Phys << std::endl;
    std::cout << "L_ch_LB [Lu] = " << CaseParameters_Ptr->CharacteristicLength_L_CH_LB << std::endl;
    std::cout << "Nu_LB = " << CaseParameters_Ptr->FluidLBuViscosity_Nu_LB << std::endl;
    std::cout << "Fx_LB = " << CaseParameters_Ptr->ForceX_LB << std::endl;
    std::cout << "Fy_LB = " << CaseParameters_Ptr->ForceY_LB << std::endl;
    std::cout << "Fz_LB = " << CaseParameters_Ptr->ForceZ_LB << "\n" << std::endl;
}

void MF::Solver_CPU::ConsoleWriter::PrintGridStatistics(const std::shared_ptr<MF::Database::ThreadArray>& ThreadArray_Ptr) {

    // Console output formatting
    std::cout.fill(' ');
    std::cout.setf(std::ios::left);
    std::cout.setf(std::ios::scientific);

    std::cout<<"Grid statistics: " << std::endl;
    std::cout<<"Total number of computational nodes = " << MF::Solver_CPU::Calculations::getTotalNodeNumber(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of solid (0) nodes = " << MF::Solver_CPU::Calculations::getSolidNodeNumber_1(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of fluid (1) nodes = " << MF::Solver_CPU::Calculations::getFluidNodeNumber_1(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of bounce back (61) nodes = " << MF::Solver_CPU::Calculations::getBBNodeNumber_61(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of velocity (20) nodes = " << MF::Solver_CPU::Calculations::getVelocityNodeNumber_20(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of velocity0 (40) nodes = " << MF::Solver_CPU::Calculations::getVelocity0NodeNumber_40(ThreadArray_Ptr) << std::endl;
    std::cout<<"Number of pressure (30) nodes = " << MF::Solver_CPU::Calculations::getPressureNodeNumber_30(ThreadArray_Ptr) << std::endl;
    std::cout << "Number of periodic (4) and (5) nodes = " << MF::Solver_CPU::Calculations::getPeriodicNodeNumber_4(ThreadArray_Ptr) << std::endl;
    double total = MF::Solver_CPU::Calculations::getTotalNodeNumber(ThreadArray_Ptr);
    double fluid = MF::Solver_CPU::Calculations::getFluidNodeNumber_1(ThreadArray_Ptr);
    float ratio = (total-fluid)/total*100;
    std::cout.unsetf(std::ios::scientific);
    std::cout<<"Ratio of non-fluid nodes to total number of computational nodes [%] = " << ratio << std::endl;
    std::cout<<"Number of MFThreads = " << ThreadArray_Ptr->m_ThreadsTable_Ptr->size() << std::endl;
    std::cout.setf(std::ios::scientific);
}

void MF::Solver_CPU::ConsoleWriter::PrintTimeStepStatistics(double& V_SimError, double& M_SimError, const unsigned int & SimStep, const std::shared_ptr<MF::Database::ThreadArray>& ThreadArray_Ptr, const std::shared_ptr<MF::Solver_CPU::CaseParameters>& CaseParameters_Ptr) {
    auto VSum2 = MF::Solver_CPU::Calculations::VelocityLBVolumeSum(ThreadArray_Ptr);
    auto uLB_maks = MF::Solver_CPU::Calculations::getULBmaks(ThreadArray_Ptr);
    auto Time_now = std::chrono::high_resolution_clock::now();
    double cpu_time = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1> >> (Time_now - m_TimePreviousStep).count();
    double MLUPS = (SimStep - m_SimPreviousStep) * MF::Solver_CPU::Calculations::getTotalNodeNumber(ThreadArray_Ptr) / cpu_time / 1e6;
    double SimError_Vel = fabs((VSum2 - m_VSum) * 2 / (VSum2 + m_VSum) / (SimStep - m_SimPreviousStep));

    if (m_minMLUPS == 0)
        m_minMLUPS = MLUPS;
    else if (m_minMLUPS > MLUPS)
        m_minMLUPS = MLUPS;
    if (m_maxMLUPS < MLUPS)
        m_maxMLUPS = MLUPS;
    m_VSum = VSum2;
    m_SimPreviousStep = SimStep;
    m_TimePreviousStep = Time_now;
    m_iter ++;

    // Velocity error calculations
    if (CaseParameters_Ptr->Sc_VelocityResidueError_ErrV > 0)
        V_SimError = SimError_Vel;
    else
        V_SimError = 0;

    double OutVMean, InVMean, DMF, DMF_LB;

    if (CaseParameters_Ptr->AutomaticSurfaceChoice){
        OutVMean = MF::Solver_CPU::Calculations::VelocityFizMeanForPNodes(ThreadArray_Ptr);
        InVMean = MF::Solver_CPU::Calculations::VelocityFizMeanForVNodes(ThreadArray_Ptr);
        DMF = MF::Solver_CPU::Calculations::DeltaMassFlow_fiz(ThreadArray_Ptr,CaseParameters_Ptr);
        DMF_LB = MF::Solver_CPU::Calculations::DeltaMassFlowLB(ThreadArray_Ptr,CaseParameters_Ptr);
    }
    else{
        OutVMean = MF::Solver_CPU::Calculations::VelocityFizMeanForOutlet(ThreadArray_Ptr);
        InVMean = MF::Solver_CPU::Calculations::VelocityFizMeanForInlet(ThreadArray_Ptr);
        DMF = MF::Solver_CPU::Calculations::DeltaMassFlowThread_fiz(ThreadArray_Ptr,CaseParameters_Ptr);
        DMF_LB = MF::Solver_CPU::Calculations::DeltaMassFlowThread_LB(ThreadArray_Ptr,CaseParameters_Ptr);
    }

    // Mass flow error calculations
    if (CaseParameters_Ptr->MassFlowError_ErrM > 0)
        M_SimError = fabs(DMF);
    else
        M_SimError = 0;

    //Table legend
    if (m_iter == 1){
        std::cout << "Table legend: " << "Sc = Scaled, " << "M = Mean, " << "MLUPS = Million of Lattice nodes Updated Per Second." << std::endl;
    }

    //Table header
    if (m_iter % 20 == 0 || m_iter == 1) {
        std::cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;
        std::cout << "|" << " Step    " << "|" << " Sc velocity residue, [-] " << "|" << " Maximal LB velocity, [-] " << "|" << " M outlet velocity, [m/s]  " << "|" << " M inlet velocity, [m/s]  "
        << "|" << " Error mass flow, [%] " << "|" << " Error mass flow LB, [%] " << "|" << " MLUPS, [-]             " << "|" << std::endl;
        std::cout << std::setw(194) << std::setfill('=') << "=" << std::setfill(' ') << std::endl;
    }

    //Table values
    std::cout << "| " << std::setw(8) << SimStep << "|" << " DeltaV = " << std::setw(16) << SimError_Vel << "|" << " uLB_maks = " << std::setw(14) << uLB_maks << "|"
              << " OutVMean = " << std::setw(15) << OutVMean << "|" << " InVMean = " << std::setw(15) << InVMean << "|" << " DMF = " << std::setw(15) << DMF << "|"
              << " DMF_LB = " << std::setw(15) << DMF_LB << "|" << " MLUPS = " << std::setw(15) << MLUPS << "|" << std::endl;

    return;
}

void MF::Solver_CPU::ConsoleWriter::ThreadsArrayInfo(const std::shared_ptr<MF::Database::ThreadArray>& ThreadArray_Ptr) {
    int nr = 0;
    for (auto & jt : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
        std::cout << std::endl << "---- Thread nr = " << ++nr << " ----" << std::endl;
        std::cout << "Thread name = " << jt.get()->m_ThreadName << std::endl;
        std::cout << "NodeTypeID = " << jt.get()->m_NodeType << std::endl;
        std::cout << "uidThreadNr = " << jt.get()->m_uidThreadNr << std::endl;
        std::cout << "m_ThreadCount = " << jt.get()->m_ThreadCount << std::endl;
        std::cout << "m_ComponentNr = " << (int)jt.get()->m_ComponentNr << std::endl;
        std::cout << "m_PhaseNr = " << (int)jt.get()->m_PhaseNr << std::endl;
        std::cout << "Do pre-collision = " << std::boolalpha << jt.get()->m_DoPreCollision << std::endl;
        std::cout << "Do collision = " << std::boolalpha << jt.get()->m_DoCollision << std::endl;
        std::cout << "Is on inlet surface = " << std::boolalpha << jt.get()->m_IsInletBalanceSurface << std::endl;
        std::cout << "Is on outlet surface = " << std::boolalpha << jt.get()->m_IsOutletBalanceSurface << std::endl;
        std::cout << "Boundary value ULB = " << "[" << jt.get()->m_BoundaryValue_ULB.x << "," << jt.get()->m_BoundaryValue_ULB.y << "," << jt.get()->m_BoundaryValue_ULB.z << "]" << std::endl;
        std::cout << "Boundary value RhoLB = " << jt.get()->m_BoundaryValue_RhoLB << std::endl;
        std::cout << "pBoundaryFunction = " << reinterpret_cast<void*>(jt.get()->m_pBoundaryFunction) << std::endl;
        std::cout << "pVRhoFunction = " << reinterpret_cast<double*>(jt.get()->m_pVRLBFunction) << std::endl;
        std::cout << "pCollideFunction = " << reinterpret_cast<void*>(jt.get()->m_pColideFunc) << std::endl;
        std::cout << "Nodes number = " << jt.get()->m_NodeArray_Ptr->size() << std::endl;
    }
}

void MF::Solver_CPU::ConsoleWriter::ThreadsNodeInfo(const std::shared_ptr<MF::Database::ThreadArray>& ThreadArray_Ptr) {
    int nr = 0;
    for (auto & jt : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
        std::cout << std::endl << "---- Thread nr = " << ++nr << " ----" << std::endl;
        std::cout << "Thread name = " << jt.get()->m_ThreadName << std::endl;
        std::cout << "NodeTypeID = " << jt.get()->m_NodeType << std::endl;
        std::cout << "uidThreadNr = " << jt.get()->m_uidThreadNr << std::endl;
        std::cout << "m_ThreadCount = " << jt.get()->m_ThreadCount << std::endl;
        std::cout << "m_ComponentNr = " << (int)jt.get()->m_ComponentNr << std::endl;
        std::cout << "m_PhaseNr = " << (int)jt.get()->m_PhaseNr << std::endl;
        std::cout << "Do pre-collision = " << std::boolalpha << jt.get()->m_DoPreCollision << std::endl;
        std::cout << "Do collision = " << std::boolalpha << jt.get()->m_DoCollision << std::endl;
        std::cout << "Is on inlet surface = " << std::boolalpha << jt.get()->m_IsInletBalanceSurface << std::endl;
        std::cout << "Is on outlet surface = " << std::boolalpha << jt.get()->m_IsOutletBalanceSurface << std::endl;
        std::cout << "Boundary value ULB = " << "[" << jt.get()->m_BoundaryValue_ULB.x << "," << jt.get()->m_BoundaryValue_ULB.y << "," << jt.get()->m_BoundaryValue_ULB.z << "]" << std::endl;
        std::cout << "Boundary value RhoLB = " << jt.get()->m_BoundaryValue_RhoLB << std::endl;
        std::cout << "pBoundaryFunction = " << reinterpret_cast<void*>(jt.get()->m_pBoundaryFunction) << std::endl;
        std::cout << "pVRhoFunction = " << reinterpret_cast<double*>(jt.get()->m_pVRLBFunction) << std::endl;
        std::cout << "pCollideFunction = " << reinterpret_cast<void*>(jt.get()->m_pColideFunc) << std::endl;
        std::cout << "Nodes number = " << jt.get()->m_NodeArray_Ptr->size() << std::endl;
        for (auto node = 0; node < jt->m_Coordinate_Ptr.get()->size(); node++){
            std::cout << "Node nr = " << node << " = [" << jt->m_Coordinate_Ptr->at(node).x << "," << jt->m_Coordinate_Ptr->at(node).y << "," << jt->m_Coordinate_Ptr->at(node).z <<"]" << std::endl;
        }
        std::cout << std::endl << "**********************************************************************************" << std::endl;
    }
}


void MF::Solver_CPU::ConsoleWriter::ExtendedInfo(const std::shared_ptr<MF::Solver_CPU::ProgramParameters>& ProgramParameters_Ptr,
                                         const std::shared_ptr<MF::Solver_CPU::CaseParameters>& CaseParameters_Ptr,
                                         const std::shared_ptr<MF::Database::ConfigData>& ConfigData_Ptr) {

    std::cout << std::endl << "**********************************************************************************" << std::endl;
    std::cout << "VERBOSE INFO ---program parameters---" << std::endl << std::endl;

    // Program parameters from the Microflow.cfg file
    std::cout << "File paths:" << std::endl;
    std::cout << "\t CaseFolder = " << ProgramParameters_Ptr->CaseFolder << std::endl;
    std::cout << "\t GeometryFolder = " << ProgramParameters_Ptr->GeometryFolder << std::endl;
    std::cout << "\t GeometryFile = " << ProgramParameters_Ptr->GeometryFileName << std::endl;
    std::cout << "\t CaseParametersFile = " << ProgramParameters_Ptr->CaseParametersFile << std::endl;
    std::cout << "\t ThreadParametersFile = " << ProgramParameters_Ptr->ThreadParametersFile << std::endl;
    std::cout << "\t ProgramParametersFile = " << ProgramParameters_Ptr->ProgramParametersFile << std::endl;
    std::cout << "\t CheckPointFile = " << ProgramParameters_Ptr->CheckPointFile << std::endl;
    std::cout << "\t OutputFile = " << ProgramParameters_Ptr->OutputFile << std::endl;

    std::cout << std::endl;
    std::cout.width(82);
    std::cout.fill('*');
    std::cout << "*" << std::endl;

    // Case parameters from the case_params.cfg file
    std::cout << "VERBOSE INFO ---case parameters---" << std::endl << std::endl;
    std::cout << "BasicParams:" << std::endl;
    if (CaseParameters_Ptr->GeometryDefinition == MF::Solver_CPU::GeometryDefinitionClass::FromSTL)
        std::cout << "\t GeometryDefinition = " << "FromSTL" << std::endl;
    else
        std::cout << "Unrecognized parameter " << std::endl;
    if (CaseParameters_Ptr->FluidFlowModel_MT == MF::Solver_CPU::FlowTypeClass::Incompressible)
        std::cout << "\t FluidFlowModel_MT = " << "Incompressible" << std::endl;
    else if (CaseParameters_Ptr->FluidFlowModel_MT == MF::Solver_CPU::FlowTypeClass::QuasiCompressible)
        std::cout << "\t FluidFlowModel_MT = " << "QuasiCompressible" << std::endl;
    else
        std::cout << "Unrecognized parameter " << std::endl;
    if (CaseParameters_Ptr->CollisionModel_KT == MF::Solver_CPU::ModelTypeClass::BGK)
        std::cout << "\t CollisionModel_KT = " << "BGK" << std::endl;
    else if (CaseParameters_Ptr->CollisionModel_KT == MF::Solver_CPU::ModelTypeClass::MRT)
        std::cout << "\t CollisionModel_KT = " << "MRT" << std::endl;
    else if (CaseParameters_Ptr->CollisionModel_KT == MF::Solver_CPU::ModelTypeClass::FBGK)
        std::cout << "\t CollisionModel_KT = " << "FBGK" << std::endl;
    else
        std::cout << "Unrecognized parameter " << std::endl;
    if (CaseParameters_Ptr->LatticeType_La == MF::Solver_CPU::LatticeTypeClass::D3Q19)
        std::cout << "\t LatticeType_La = " << "D3Q19" << std::endl;
    else
        std::cout << "Unrecognized parameter " << std::endl;
    std::cout << "\t XNodesNumber_Nx1 = " << CaseParameters_Ptr->XNodesNumber_Nx1 << std::endl;
    std::cout << "\t YNodesNumber_Ny1 = " << CaseParameters_Ptr->YNodesNumber_Ny1 << std::endl;
    std::cout << "\t ZNodesNumber_Nz1 = " << CaseParameters_Ptr->ZNodesNumber_Nz1 << std::endl;

    std::cout << std::endl << "Physical params:" << std::endl;
    std::cout << "\t FluidPhysicalViscosity_Nu_Phys = " << CaseParameters_Ptr->FluidPhysicalViscosity_Nu_Phys << std::endl;
    std::cout << "\t FluidPhysicalReferenceDensity_Rho0_Phys = " << CaseParameters_Ptr->FluidPhysicalReferenceDensity_Rho0_Phys << std::endl;
    std::cout << "\t Tau = " << CaseParameters_Ptr->Tau << std::endl;
    std::cout << "\t ForceX_fiz = " << CaseParameters_Ptr->ForceX_fiz << std::endl;
    std::cout << "\t ForceY_fiz = " << CaseParameters_Ptr->ForceY_fiz << std::endl;
    std::cout << "\t ForceZ_fiz = " << CaseParameters_Ptr->ForceZ_fiz << std::endl;

    std::cout << std::endl << "Characterstic params:" << std::endl;
    std::cout << "\t CharacteristicLengthNNodes_L_CH_LB = " << CaseParameters_Ptr->CharacteristicLength_L_CH_LB << std::endl;
    std::cout << "\t CharactLengthPhysical_L_CH_Phys = " << CaseParameters_Ptr->CharactLengthPhysical_L_CH_Phys << std::endl;
    std::cout << "\t CharactVelocityPhysical_U_CH_Phys = " << CaseParameters_Ptr->CharactVelocityPhysical_U_CH_Phys << std::endl;

    std::cout << std::endl << "Termination conditions:" << std::endl;
    std::cout << "\t Sc_VelocityResidueError_ErrV = " << CaseParameters_Ptr->Sc_VelocityResidueError_ErrV << std::endl;

    std::cout << std::endl << "Initial conditions:" << std::endl;
    std::cout << "\t ReferenceDensityLB_Rho0_LB = " << CaseParameters_Ptr->ReferenceDensityLB_Rho0_LB << std::endl;
    std::cout << "\t XInitialVelocityUx0_Phys = " << CaseParameters_Ptr->XInitialVelocityUx0_Phys << std::endl;
    std::cout << "\t YInitialVelocityUy0_Phys = " << CaseParameters_Ptr->YInitialVelocityUy0_Phys << std::endl;
    std::cout << "\t ZInitialVelocityUz0_Phys = " << CaseParameters_Ptr->ZInitialVelocityUz0_Phys << std::endl;

    std::cout << std::endl << "Default boundary conditions:" << std::endl;
    std::cout << "\t DefaultWallNode_BN = " << CaseParameters_Ptr->DefaultWallNode_BN << std::endl;
    std::cout << "\t DefaultNode_NN = " << CaseParameters_Ptr->DefaultNode_NN << std::endl;

    std::cout << std::endl << "RWParams:" << std::endl;
    std::cout << "\t CheckPointNumberRead_CHP_R = " << CaseParameters_Ptr->CheckPointNumberRead_CHP_R << std::endl;
    std::cout << "\t ConsoleWriteStep_K_W = " << CaseParameters_Ptr->ConsoleWriteStep_K_W << std::endl;
    std::cout << "\t VTKWriteStep_VTK_W = " << CaseParameters_Ptr->VTKWriteStep_VTK_W << std::endl;
    std::cout << "\t VTKFileMaxNumber_VTK_Max = " << CaseParameters_Ptr->VTKFileMaxNumber_VTK_Max << std::endl;

    std::cout << std::endl << "ThreadParams:" << std::endl;
    std::cout << "\t ThreadMaxSize = " << CaseParameters_Ptr->ThreadMaxSize << std::endl;

    //Mass balance surface choice params
    std::cout << std::endl << "BalanceParams:" << std::endl;
    std::cout << "\t AutomaticSurfaceChoice = " << CaseParameters_Ptr->AutomaticSurfaceChoice << std::endl;

    // CPU parameters
    std::cout << std::endl << "CPUParams:" << std::endl;
    std::cout << "\t CPU_ThreadsNr = " << CaseParameters_Ptr->CPU_ThreadsNr << std::endl;

    std::cout << std::endl << "**********************************************************************************" << std::endl << std::endl;

    // Thread file reader -------------------------------------------------------------------------------------
    std::cout << "Threads defined in thread_params.cfg file" << std::endl;
    std::cout << "Total number of threads = " << ConfigData_Ptr->getThreadsNumber() << std::endl;
    for (int j = 0; j < ConfigData_Ptr->getThreadsNumber(); j++) {
        std::cout << "#########################################################################################################################" << std::endl;
        std::cout << "ThreadID = " << j << std::endl;
        std::cout << "ThreadName = " << ConfigData_Ptr->getThreadStringParam(j, "ThreadName") << std::endl;
        std::cout << "GridType = " << ConfigData_Ptr->getThreadStringParam(j, "GridType") << std::endl;
        if (ConfigData_Ptr->getThreadParamLength(j, "NodeTypeID") > 0)
            std::cout << "NodeTypeID = " << ConfigData_Ptr->getThreadIntParam(j, "NodeTypeID") << std::endl;
        std::cout << "Data number = " << ConfigData_Ptr->getThreadParamLength(j, "uid-Node") << std::endl;
        if (ConfigData_Ptr->getThreadParamLength(j, "uid-Node") > 0)
            for (int i = 0; i < ConfigData_Ptr->getThreadParamLength(j, "uid-Node"); i++) {
                if (i > 0) std::cout << std::endl;
                std::cout << "Node, Coordinate = " << "[" << ConfigData_Ptr->getThreadDataIntVectorParam(0, j, i, "uid-Node", "Coordinate") << ", "
                     << ConfigData_Ptr->getThreadDataIntVectorParam(1, j, i, "uid-Node", "Coordinate")
                     << ", " << ConfigData_Ptr->getThreadDataIntVectorParam(2, j, i, "uid-Node", "Coordinate") << "]";
                if (ConfigData_Ptr->getThreadDataVectorParamLength(j, i, "uid-Node", "Velocity") > 0)
                    std::cout << ", Velocity = " << "[" << ConfigData_Ptr->getThreadDataFloatVectorParam(0, j, i, "uid-Node", "Velocity") << ", "
                         << ConfigData_Ptr->getThreadDataFloatVectorParam(1, j, i, "uid-Node", "Velocity")
                         << ", " << ConfigData_Ptr->getThreadDataFloatVectorParam(2, j, i, "uid-Node", "Velocity") << "]";
                if (i == ConfigData_Ptr->getThreadParamLength(j, "uid-Node") - 1) std::cout << std::endl;
            }
        if (ConfigData_Ptr->getThreadParamLength(j, "Velocity_fiz") > 0)
            std::cout << "Velocity = " << "[" << ConfigData_Ptr->getThreadFloatVectorParam(0, j, "Velocity_fiz") << ", " << ConfigData_Ptr->getThreadFloatVectorParam(1, j, "Velocity_fiz")
                 << ", " << ConfigData_Ptr->getThreadFloatVectorParam(2, j, "Velocity_fiz") << "]" << std::endl;
        if (ConfigData_Ptr->getThreadParamLength(j, "NodeCoordinateFileColumnNames") > 0)
            std::cout << "NodeCoordinateFileColumnNames = " << "[" << ConfigData_Ptr->getThreadStringVectorParam(0, j, "NodeCoordinateFileColumnNames")
                 << ", " << ConfigData_Ptr->getThreadStringVectorParam(1, j, "NodeCoordinateFileColumnNames") << ", "
                 << ConfigData_Ptr->getThreadStringVectorParam(2, j, "NodeCoordinateFileColumnNames") << "]" << std::endl;
        if (ConfigData_Ptr->getThreadParamLength(j, "NodeFilePath") > 0) {
            std::cout << "NodeFilePath = " << ConfigData_Ptr->getThreadStringParam(j, "NodeFilePath") << std::endl;
            std::string FilePath =
                    ConfigData_Ptr->CaseFolder + ConfigData_Ptr->getProgramStringParam("GeometryFolder") + ConfigData_Ptr->getThreadStringParam(j, "NodeFilePath");
            auto data_Ptr = std::make_unique<std::vector<double>>();
            std::vector<std::string> VariableNameList{ConfigData_Ptr->getThreadStringVectorParam(0, j, "NodeCoordinateFileColumnNames"),
                                                      ConfigData_Ptr->getThreadStringVectorParam(1, j, "NodeCoordinateFileColumnNames"),
                                                      ConfigData_Ptr->getThreadStringVectorParam(2, j, "NodeCoordinateFileColumnNames")};
            MF::RW::CSVReader::DataReadFromCSVFile(FilePath, VariableNameList, data_Ptr.get());
            for (auto i=data_Ptr->begin(); i != data_Ptr->end(); i++) {
                std::cout << "[" << *i; i++; std::cout << ", " << *i; i++; std::cout << ", " << *i << "]" << std::endl;
            }
        }

        if (ConfigData_Ptr->getThreadParamLength(j, "Pressure_fiz") > 0)
            std::cout << "Pressure = " << ConfigData_Ptr->getThreadFloatParam(j, "Pressure") << std::endl;

        std::cout << "#########################################################################################################################" << std::endl;
    }
}