Merge a18936c8ec into 21a7d0ab4d

src/PostprocessData/CMakeLists.txt

@@ -13,6 +13,7 @@ set(SourceFiles
     region/regionPoints/lineRegionPoints/lineRegionPoints.cpp
     region/regionPoints/centerPointsRegionPoints/centerPointsRegionPoints.cpp
     region/regionPoints/multipleSpheresRegionPoints/multipleSpheresRegionPoints.cpp
+    region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.cpp
 
     # Postprocess components
     postprocessComponent/postprocessComponent/postprocessComponent.cpp

src/PostprocessData/postprocessComponent/PostprocessComponent/PostprocessComponents.cpp

@@ -26,6 +26,7 @@ Licence:
 #include "sphereRegionPoints.hpp"
 #include "lineRegionPoints.hpp"
 #include "multipleSpheresRegionPoints.hpp"
+#include "rectMeshRegionPoints.hpp"
 
 namespace pFlow::postprocessData
 {
@@ -37,6 +38,10 @@ template class PostprocessComponentGaussian<multipleSpheresRegionPoints>;
 template class PostprocessComponentUniform<multipleSpheresRegionPoints>;
 template class PostprocessComponentArithmetic<multipleSpheresRegionPoints>;
 
+template class PostprocessComponentGaussian<rectMeshRegionPoints>;
+template class PostprocessComponentUniform<rectMeshRegionPoints>;
+template class PostprocessComponentArithmetic<rectMeshRegionPoints>;
+
 template class PostprocessComponentGaussian<lineRegionPoints>;
 template class PostprocessComponentUniform<lineRegionPoints>;
 template class PostprocessComponentArithmetic<lineRegionPoints>;

src/PostprocessData/region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.cpp

@@ -0,0 +1,98 @@
+#include "rectMeshRegionPoints.hpp"
+#include "fieldsDataBase.hpp"
+#include "numericConstants.hpp"
+
+namespace pFlow::postprocessData
+{
+
+rectMeshRegionPoints::rectMeshRegionPoints
+(
+    const dictionary &dict, 
+    fieldsDataBase &fieldsDataBase
+)
+:
+    regionPoints(dict, fieldsDataBase)
+{
+
+    const auto& rectMeshInfo = dict.subDict("rectMeshInfo");
+
+    auto minP = rectMeshInfo.getVal<realx3>("min");
+    auto maxP = rectMeshInfo.getVal<realx3>("max");
+    auto nx = rectMeshInfo.getValMax<uint32>("nx", 1);
+    auto ny = rectMeshInfo.getValMax<uint32>("ny", 1);
+    auto nz = rectMeshInfo.getValMax<uint32>("nz", 1);
+    
+    boxRegion_ = box(minP, maxP);
+    cells_ = uint32x3(nx, ny, nz);
+    uint32 nCells = nx * ny * nz;
+    
+    volumes_.resize(nCells, boxRegion_.volume() / nCells);
+    diameter_.resize(nCells, 2 * pow(3 * boxRegion_.volume() / nCells / 4.0 / Pi, 1.0 / 3.0));
+    selectedPoints_.resize(nCells);
+    centerPoints_.resize(nCells);
+
+    
+    for(uint32 i = 0; i < nx; ++i)
+    {
+        for(uint32 j = 0; j < ny; ++j)
+        {
+            for(uint32 k = 0; k < nz; ++k)
+            {
+                // calculate the center point of each cell
+                uint32 index = (i * ny + j) * nz + k;
+                realx3 center = boxRegion_.minPoint() + 
+                    realx3(
+                        (i + 0.5) * (boxRegion_.maxPoint().x() - boxRegion_.minPoint().x()) / nx,
+                        (j + 0.5) * (boxRegion_.maxPoint().y() - boxRegion_.minPoint().y()) / ny,
+                        (k + 0.5) * (boxRegion_.maxPoint().z() - boxRegion_.minPoint().z()) / nz
+                    );
+                centerPoints_[index] = center;
+            }
+        }
+    }
+}
+
+bool rectMeshRegionPoints::update()
+{
+    const auto points = database().updatePoints();
+    for (auto& elem : selectedPoints_)
+    {
+        elem.clear();
+    }
+
+    real dx = (boxRegion_.maxPoint().x() - boxRegion_.minPoint().x()) / cells_.x();
+    real dy = (boxRegion_.maxPoint().y() - boxRegion_.minPoint().y()) / cells_.y();
+    real dz = (boxRegion_.maxPoint().z() - boxRegion_.minPoint().z()) / cells_.z();
+
+    for (uint32 i = 0; i < points.size(); ++i)
+    {
+        if(boxRegion_.isInside(points[i]))
+        {
+            uint indexX = (points[i] - boxRegion_.minPoint()).x() / dx;
+            uint indexY = (points[i] - boxRegion_.minPoint()).y() / dy;
+            uint indexZ = (points[i] - boxRegion_.minPoint()).z() / dz;
+            uint cellIndex = (indexX * cells_.y() + indexY) * cells_.z() + indexZ;
+            selectedPoints_[cellIndex].push_back(i);
+        }
+    }
+    return true;
+}
+
+bool rectMeshRegionPoints::write(iOstream &os) const
+{
+    os << "# rect mesh region points\n";
+    os <<"# min point: "<< boxRegion_.minPoint() << endl;
+    os <<"# max point: "<< boxRegion_.maxPoint() << endl;
+    os <<"# nx: "<< cells_.x() <<endl;
+    os <<"# ny: "<< cells_.y() <<endl;
+    os <<"# nz: "<< cells_.z() <<endl;
+    os << "time/No. ";
+    for (uint32 i = 0; i < cells_.x() * cells_.y() * cells_.z(); ++i)
+    {
+        os << i << "  ";
+    }
+    os << endl;
+    return true;
+}
+
+} // End namespace pFlow::postprocessData

src/PostprocessData/region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.hpp

@@ -0,0 +1,192 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions.
+
+  phasicFlow is distributed to help others in their research in the field of
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+/**
+ * @file rectMeshRegionPoints.hpp
+ * @brief A class representing a rectMesh region for point selection
+ * 
+ * This class provides functionality to select points within a rectMesh region
+ * and to compute related properties such as volume and equivalent diameter.
+ * It inherits from regionPoints and implements all required virtual methods.
+ * 
+ * @see regionPoints
+ * @see rectMesh
+ * @see fieldsDataBase
+ */
+
+#ifndef __rectMeshRegionPoints_hpp__
+#define __rectMeshRegionPoints_hpp__
+
+#include "regionPoints.hpp"
+#include "box.hpp"
+#include "Vectors.hpp"
+#include "cells.hpp"
+
+namespace pFlow::postprocessData
+{
+
+class rectMeshRegionPoints
+:
+    public regionPoints
+{
+private:
+
+    /// box object defining the region for point selection
+    box  boxRegion_;
+
+    /// store the cells that are inside the box region
+    uint32x3   cells_;
+
+    /// Center points of each cell in the rectMesh region
+    realx3Vector    centerPoints_;
+
+    /// Volume of each cell in the rectMesh region
+    realVector    volumes_;
+
+    /// Diameter of each cell in the rectMesh region
+    realVector    diameter_;
+
+    /// Indices of points that are selected by this region
+    Vector<uint32Vector>    selectedPoints_;
+
+public:
+
+    TypeInfo("rectMesh");
+
+    /**
+     * @brief Construct a rectMesh region for point selection
+     * 
+     * @param dict Dictionary containing sphereInfo dictionary 
+     * @param fieldsDataBase Database containing fields data
+     */
+    rectMeshRegionPoints(
+        const dictionary& dict,
+        fieldsDataBase& fieldsDataBase);
+
+    /// Destructor
+    ~rectMeshRegionPoints() override = default;
+    
+    /**
+     * @brief Get the number of regions
+     */
+    uint32 size()const override
+    {
+        return volumes_.size();
+    }
+
+    /**
+     * @brief Check if the region is empty
+     * @return Always returns false
+     */
+    bool empty()const override
+    {
+        return volumes_.empty();
+    }
+
+    /**
+     * @brief Get the volume of the rectMesh region
+     * @return A span containing the volume of the region
+     */
+    span<const real> volumes()const override
+    {
+        return span<const real>(volumes_.data(), volumes_.size());
+    }
+
+    /**
+     * @brief Get the equivalent diameter of the rectMesh region
+     * @return A span containing the diameter of the region
+     */
+    span<const real> eqDiameters()const override
+    {
+        return span<const real>(diameter_.data(), diameter_.size());
+    }
+
+    /**
+     * @brief Get the center of the rectMesh region
+     * @return A span containing the center point of the region
+     */
+    span<const realx3> centers()const override
+    {
+        return span<const realx3>(centerPoints_.data(), centerPoints_.size());
+    }
+    
+    /**
+     * @brief Get the indices of points within the region (const version)
+     * @param elem Element index (ignored as there's only one sphere)
+     * @return A span containing indices of points within the region
+     */    
+    span<const uint32> indices(uint32 elem)const override
+    {
+        if (elem >= size())
+        {
+        fatalErrorInFunction
+            << "The element index is out of range. elem: " << elem
+            << " size: " << size() << endl;
+            fatalExit;
+        }
+
+        return span<const uint32>(selectedPoints_[elem].data(), selectedPoints_[elem].size());
+    }
+
+    /**
+     * @brief Get the indices of points within the region (non-const version)
+     * @param elem Element index (ignored as there's only one sphere)
+     * @return A span containing indices of points within the region
+     */
+    span<uint32> indices(uint32 elem) override
+    {
+        if (elem >= size())
+        {
+            fatalErrorInFunction
+            << "The element index is out of range. elem: " << elem
+            << " size: " << size() << endl;
+            fatalExit;
+        }
+
+    return span<uint32>(selectedPoints_[elem].data(), selectedPoints_[elem].size());
+    }
+
+    /**
+     * @brief Update the points selected by this region
+     * @return True if update was successful
+     */
+    bool update()override;
+
+    /**
+     * @brief Determine if data should be written to the same time file
+     * @return Always returns true
+     */
+    bool writeToSameTimeFile()const override
+    {
+        return true;
+    }
+
+    /**
+     * @brief Write region data to output stream
+     * @param os Output stream to write to
+     * @return True if write was successful
+     */
+    bool write(iOstream& os)const override;
+    
+};
+
+}
+
+#endif // __sphereRegionPoints_hpp__

src/phasicFlow/structuredData/box/box.hpp

@@ -111,6 +111,14 @@ public:
             return max_;
         }
 
+		INLINE_FUNCTION_HD
+		real volume()const
+		{
+			return (max_.x() - min_.x()) * 
+                   (max_.y() - min_.y()) * 
+                   (max_.z() - min_.z()); 
+		}
+
 	//// - IO operation 
 		FUNCTION_H
 		bool read(iIstream & is);