Thread.h

Go to the documentation of this file.

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

#include <cstdint>
#include <memory>
#include <vector>
#include <omp.h>
#include <iostream>
#include <algorithm>

#include "MFDatabase/Node.h"
#include "MFDatabase/NodePropArray.h"
#include "MFDatabase/Vec3.h"
#include "MFDatabase/Vec4.h"
#include "GeometryBuilder/NodeID.h"
#include "GridUtilities/LatticeParametersD3Q19.h"

namespace MF {
    namespace Database {

        class Thread {
        public:
            Thread (uint64_t NodeID, uint32_t NrOfNodes){
                MF::GB::NodeID nodeTMP;
                nodeTMP.node_id.NodeID = NodeID;
                m_NodeArray_Ptr = std::make_shared<std::vector<MF::Database::Node>>(NrOfNodes);
                m_PropagationTable_Ptr = std::make_shared<NodePropArray>(NrOfNodes);
                m_SecondHalfPropagationTable_Ptr = std::make_shared<NodePropArray>(NrOfNodes);
                m_Coordinate_Ptr = std::make_shared<std::vector<MF::Database::Vec3<int32_t>>>(NrOfNodes);
                m_NodeType = nodeTMP.node_id.Node.nodeType;
                m_uidThreadNr = nodeTMP.node_id.Node.uidThreadNr;
                m_ThreadCount = nodeTMP.node_id.Node.ThreadCount;
                m_ComponentNr = nodeTMP.node_id.Node.ComponentNr;
                m_PhaseNr = nodeTMP.node_id.Node.PhaseNr; };

            ~Thread() = default;

            static std::shared_ptr<MF::Database::Thread> New(const std::shared_ptr<MF::GU::LatticeParametersD3Q19>& LatticeParameters_Ptr, uint64_t NodeID, uint32_t NrOfNodes) {
                auto Thread_Ptr = std::make_shared<MF::Database::Thread>(NodeID, NrOfNodes);
                Thread_Ptr->m_Thread_Ptr = Thread_Ptr;
                MF::Database::Thread::m_LatticeParameters_Ptr = LatticeParameters_Ptr;
                return Thread_Ptr;
            }

            inline static std::shared_ptr<MF::GU::LatticeParametersD3Q19> m_LatticeParameters_Ptr; 
            std::shared_ptr<MF::Database::Thread> m_Thread_Ptr {nullptr}; 
            std::string m_ThreadName {""}; 
            uint16_t m_NodeType {0}; 
            uint16_t m_uidThreadNr {0}; 
            uint16_t m_ThreadCount {0}; 
            uint8_t m_ComponentNr {0}; 
            uint8_t m_PhaseNr {0}; 
            bool m_DoPreCollision {false}; 
            bool m_DoCollision {false}; 
            bool m_DoPropagation {true}; 
            bool m_IsInletBalanceSurface {false}; 
            bool m_IsOutletBalanceSurface {false}; 

            MF::Database::Vec3<double> m_BoundaryValue_ULB {0, 0, 0}; 
            double m_BoundaryValue_RhoLB {1.0}; 
            MF::Database::Vec3<double> m_XYZForce_LB {0.0,0.0,0.0}; 

            void (*m_pBoundaryFunction)(MF::Database::Node*) {nullptr}; 
            MF::Database::Vec4<double> (*m_pVRLBFunction)(const MF::Database::Node*) {nullptr}; 
            void (*m_pColideFunc)(MF::Database::Node*) {nullptr}; 

            std::shared_ptr<std::vector<MF::Database::Node>> m_NodeArray_Ptr {nullptr}; 
            std::shared_ptr<NodePropArray> m_PropagationTable_Ptr {nullptr}; 
            std::shared_ptr<NodePropArray> m_SecondHalfPropagationTable_Ptr {nullptr}; 
            std::shared_ptr<std::vector<MF::Database::Vec3<int32_t>>> m_Coordinate_Ptr = {nullptr}; 

            // Accessors ----------------------------------------------------------------------------------------------------------------------------------------------------------
            inline MF::Database::Node* getPropTableNodePointer(const std::size_t &nodeNr, const uint8_t &LinkNr) {return (*m_PropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline MF::Database::Node* getSecPropTableNodePointer(const std::size_t &nodeNr, const uint8_t &LinkNr) {return (*m_SecondHalfPropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline MF::Database::Node* getPropTableNodePointer(const MF::Database::Node* nodePointer, const uint8_t &LinkNr) {std::size_t nodeNr = nodePointer - m_NodeArray_Ptr->data(); return (*m_PropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline std::size_t getNodeNr(const MF::Database::Node* nodePointer) {return nodePointer - m_NodeArray_Ptr->data();}; 
            inline MF::Database::Node& getPropTableNodeRef(const std::size_t &nodeNr, const uint8_t &LinkNr) {return *(*m_PropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline MF::Database::Node& getSecondPropTableNodeRef(const std::size_t &nodeNr, const uint8_t &LinkNr) {return *(*m_PropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline void setNodePtrInPropTable(const std::size_t &nodeNr, const uint8_t &LinkNr, MF::Database::Node* nodePtr) { (*m_PropagationTable_Ptr)[nodeNr][LinkNr] = nodePtr;}; 
            inline void setNodePtrInSecondPropTable(const std::size_t &nodeNr, const uint8_t &LinkNr, MF::Database::Node* nodePtr) { (*m_SecondHalfPropagationTable_Ptr)[nodeNr][LinkNr] = nodePtr;}; 
            inline MF::Database::Node& getPropTableNodeRef(const MF::Database::Node* nodePointer, const uint8_t &LinkNr) {std::size_t nodeNr = nodePointer - m_NodeArray_Ptr->data(); return *(*m_PropagationTable_Ptr)[nodeNr][LinkNr];}; 
            inline MF::Database::Node& getNodeRef(const std::size_t &nodeNr) {return (*m_NodeArray_Ptr)[nodeNr];}; 
            inline MF::Database::Node* getNodePointer(const std::size_t &nodeNr) {return &(*m_NodeArray_Ptr)[nodeNr];}; 
            inline int32_t& getNodeCoordX(const std::size_t &nodeNr){return (*m_Coordinate_Ptr)[nodeNr].x;}; 
            inline int32_t& getNodeCoordY(const std::size_t &nodeNr){return (*m_Coordinate_Ptr)[nodeNr].y;}; 
            inline int32_t& getNodeCoordZ(const std::size_t &nodeNr){return (*m_Coordinate_Ptr)[nodeNr].z;}; 
            inline void setNodeCoordX(const std::size_t &nodeNr, const int32_t& X){(*m_Coordinate_Ptr)[nodeNr].x = X;}; 
            inline void setNodeCoordY(const std::size_t &nodeNr, const int32_t& Y){(*m_Coordinate_Ptr)[nodeNr].y = Y;}; 
            inline void setNodeCoordZ(const std::size_t &nodeNr, const int32_t& Z){(*m_Coordinate_Ptr)[nodeNr].z = Z;}; 
            inline uint32_t getNumberOfNodes () {return m_NodeArray_Ptr->size();}; 

            inline MF::Database::Node* getLinkedNodePointer(const std::size_t &nodeNr, const uint8_t f){
                for (auto k = 0; k < MFQ19_H; k++){
                    auto direction1 = MF::GU::LatticeParametersD3Q19::SwapDirections[k][0];
                    auto direction2 = MF::GU::LatticeParametersD3Q19::SwapDirections[k][1];
                    if (f == direction1)
                        return getPropTableNodePointer(nodeNr, k);
                    else if (f == direction2)
                        return getSecPropTableNodePointer(nodeNr, k);
                    else if (f == 0)
                        return getNodePointer(nodeNr);
                }
                return nullptr;
            };

            void inline DoCollisionOnly(const int& CPU_ThreadsNr) {
                std::size_t node;
                omp_set_num_threads(CPU_ThreadsNr);
                #pragma omp parallel for default(none) schedule(guided) //OpenMP compilation directive
                for (node = 0; node < m_NodeArray_Ptr->size(); node++) {
                    (*m_pColideFunc)(&(*m_NodeArray_Ptr)[node]);
                }
            };

            void inline DoPreCollisionOnly(const int& CPU_ThreadsNr) {
                std::size_t node;
                omp_set_num_threads(CPU_ThreadsNr); // Number of CPU threads to use
                #pragma omp parallel for default(none) schedule(guided) //OpenMP compilation directive
                for (node = 0; node < m_NodeArray_Ptr->size(); node++) {
                    (*m_pBoundaryFunction)(&(*m_NodeArray_Ptr)[node]);
                }
            };

            void inline DoPreANDCollision(const int& CPU_ThreadsNr) {
                std::size_t node;
                omp_set_num_threads(CPU_ThreadsNr); // Number of CPU threads to use
                #pragma omp parallel for default(none) schedule(guided) //OpenMP compilation directive
                for (node = 0; node < m_NodeArray_Ptr->size(); node++) {
                    (*m_pBoundaryFunction)(&(*m_NodeArray_Ptr)[node]);
                    (*m_pColideFunc)(&(*m_NodeArray_Ptr)[node]);
                }
            };

            void inline DoPropagation(const int& CPU_ThreadsNr) {
                std::size_t node;
                uint64_t LinkNr;
                omp_set_num_threads(CPU_ThreadsNr); // Number of CPU threads to use
                #pragma omp parallel for schedule(static) default(none) private(LinkNr)//OpenMP compilation directive
                for (node = 0; node < m_NodeArray_Ptr->size(); node++) {
                    for (LinkNr = 0; LinkNr < MFQ19_H; LinkNr++) {
                        if (getPropTableNodePointer(node, LinkNr) != nullptr) {
                            const auto link1 = m_LatticeParameters_Ptr->SwapDirections[LinkNr][0];
                            const auto link2 = m_LatticeParameters_Ptr->SwapDirections[LinkNr][1];
                            std::swap(getPropTableNodeRef(node, LinkNr).FQ19[link1],(*m_NodeArray_Ptr)[node].FQ19[link2]);
                        }
                    }
                }
            };
        };

    } /* namespace Database */
} /* namespace MF */