The main structure is tested. functons like execute and write are added and tested.

other components are left

src/PostprocessData/operation/postprocessOperation/postprocessOperation.cpp

@@ -0,0 +1,193 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+#include "Time.hpp"
+#include "postprocessOperation.hpp"
+#include "regionPoints.hpp"
+#include "fieldsDataBase.hpp"
+
+namespace pFlow
+{
+
+template<typename T>
+inline
+bool writeField
+(
+    iOstream&             os,
+    timeValue             t,
+    const regionField<T>  field,
+    uint32                threshold,
+    const T&              defValue=T{}    
+)
+{
+    const auto& regPoints = field.regPoints();
+    const uint32 n = field.size();
+    os<<t<<tab;
+    for(uint32 i=0; i<n; i++)
+    {
+        auto numPar = regPoints.indices(i).size();
+        if(numPar >= threshold)
+        {
+            if constexpr(std::is_same_v<T,realx3>)
+            {
+                os<<field[i].x()<<' '<<field[i].y()<<' '<<field[i].z()<<tab;
+            }
+            else if constexpr( std::is_same_v<T,realx4>)
+            {
+                os << field[i].x() << ' ' << field[i].y() << ' ' << field[i].z() << ' ' << field[i].w() << tab;
+            }
+            else
+            {
+                os<<field[i]<<tab;
+            }
+            
+        }
+        else
+        {
+            if constexpr(std::is_same_v<T,realx3>)
+            {
+                os<<defValue.x()<<' '<<defValue.y()<<' '<<defValue.z()<<tab;
+            }
+            else if constexpr( std::is_same_v<T,realx4>)
+            {
+                os << defValue.x() << ' ' << defValue.y() << ' ' << defValue.z() << ' ' << defValue.w() << tab;
+            }
+            else
+            {
+                os<<defValue<<tab;
+            }
+        }
+
+    }
+    os<<endl;
+    return true;
+}
+
+}
+
+
+
+pFlow::postprocessOperation::postprocessOperation
+(
+    const dictionary &opDict, 
+    const regionPoints& regPoints,
+    fieldsDataBase &fieldsDB
+)
+:
+    operationDict_(opDict),
+    threshold_
+    (
+        opDict.getValOrSet<int>("threshold", 1)
+    ),
+    divideByVolume_
+    (
+        opDict.getValOrSet<Logical>("dividedByVolume", Logical(false))
+    ),
+    regionPoints_
+    (
+        regPoints
+    ),
+    database_
+    (
+        fieldsDB
+    ),
+    fieldName_
+    (
+        opDict.getValOrSet<word>("field", "one")
+    ),
+    phiFieldName_
+    (
+        opDict.getValOrSet<word>("phi", "one")
+    ),
+    includeMask_
+    (
+        includeMask::create(opDict, fieldsDB)
+    )
+{
+
+    if(!fieldsDB.getPointFieldType(fieldName_, fieldType_))
+    {
+        fatalErrorInFunction;
+        fatalExit;
+    }
+}
+
+const pFlow::Time& pFlow::postprocessOperation::time() const
+{
+    return database_.time();
+}
+
+bool pFlow::postprocessOperation::write(const fileSystem &parDir) const
+{   
+    auto ti = time().TimeInfo();
+
+    if(!osPtr_)
+    {
+        fileSystem path = parDir+(
+            processedFieldName() + ".Start_" + ti.prevTimeName());
+        osPtr_ = makeUnique<oFstream>(path);
+        
+        regPoints().write(osPtr_());
+    }
+
+    const auto& field = processedField();
+
+    std::visit
+    (
+        [&](auto&& arg)->bool
+        {
+            return writeField(osPtr_(), ti.t(), arg, threshold_);
+        },
+        field
+    );
+
+    return true;
+}
+
+pFlow::uniquePtr<pFlow::postprocessOperation>
+pFlow::postprocessOperation::create(
+    const dictionary &opDict,
+    const regionPoints &regPoints,
+    fieldsDataBase &fieldsDB)
+{
+    word func = opDict.getVal<word>("function");
+    word method = angleBracketsNames("PostprocessOperation", func);
+    if( dictionaryvCtorSelector_.search(method) )
+    {
+        REPORT(3)<<"Operation "<< Green_Text(opDict.name())<<" with function "<< Green_Text(func)<<endl;
+        auto objPtr = 
+            dictionaryvCtorSelector_[method]
+            (opDict, regPoints, fieldsDB);
+        return objPtr;
+    }
+    else
+    {
+        printKeys
+        ( 
+            fatalError << "Ctor Selector "<< 
+            method << " dose not exist. \n"
+            <<"Avaiable ones are: \n\n"
+            ,
+            dictionaryvCtorSelector_
+        );
+        fatalExit;
+        return nullptr;
+    }
+}

src/PostprocessData/operation/postprocessOperation/postprocessOperation.hpp

@@ -0,0 +1,189 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+#ifndef __postprocessOperation_hpp__
+#define __postprocessOperation_hpp__
+
+#include <variant>
+
+#include "virtualConstructor.hpp"
+#include "Logical.hpp"
+#include "dictionary.hpp"
+#include "span.hpp"
+#include "oFstream.hpp"
+#include "regionField.hpp"
+#include "includeMask.hpp"
+
+namespace pFlow
+{
+
+using processedRegFieldType = std::variant
+    <
+        regionField<real>,
+        regionField<realx3>,
+        regionField<realx4>
+    >;
+
+class fieldsDataBase;
+class Time;
+
+/*!
+ *  @brief Base class for post-processing operations.
+ *         This class provides the basic structure and functionality
+ *         for performing post-processing operations on simulation data.
+ */
+class postprocessOperation
+{
+public:
+
+    using Mask = typename includeMask::Mask;
+
+private:
+
+    /// Dictionary containing operation-specific parameters.
+    dictionary              operationDict_;
+
+    /// This Threshold is used to exclude the regions which contain
+    /// fewer than this value. 
+    uint32                  threshold_;
+    
+    /// Logical flag to determine if the result is divided by volume.
+    Logical                 divideByVolume_;
+
+    /// Reference to the region points used in the operation.
+    const regionPoints&     regionPoints_;
+
+    /// Reference to the fields database containing field data.
+    fieldsDataBase&         database_;
+
+    /// Name of the field to be processed.
+    word                    fieldName_;
+
+    /// Type of the field to be processed.
+    word                    fieldType_;
+
+    /// Name of the phi field to be processed.
+    word                    phiFieldName_;
+
+    /// Pointer to the include mask used for masking operations.
+    uniquePtr<includeMask>  includeMask_ = nullptr;
+
+    mutable uniquePtr<oFstream>     osPtr_ = nullptr;
+    
+public:
+
+
+    TypeInfo("postprocessOperation");
+
+    postprocessOperation(
+        const dictionary& opDict,
+        const regionPoints& regPoints,
+        fieldsDataBase& fieldsDB );
+
+    virtual ~postprocessOperation()=default;
+
+    create_vCtor(
+        postprocessOperation,
+        dictionary,
+        (
+            const dictionary& opDict,
+            const regionPoints& regPoints,
+            fieldsDataBase& fieldsDB
+        ),
+        (opDict, regPoints, fieldsDB));
+    
+    const regionPoints& regPoints()const
+    {
+        return regionPoints_;
+    }
+
+    const fieldsDataBase& database()const
+    {
+        return database_;
+    }
+
+    fieldsDataBase& database()
+    {
+        return database_;
+    }
+
+    const Time& time()const;
+
+    word processedFieldName()const
+    {
+        return operationDict_.name();
+    }
+    
+    const word& fieldName()const
+    {
+        return fieldName_;
+    }
+
+    const word& fieldType()const
+    {
+        return fieldType_;
+    }
+
+    const word& phiFieldName()const
+    {
+        return phiFieldName_;
+    }
+
+    const dictionary& operationDict()const
+    {
+        return operationDict_;
+    }
+    const uint32 threshold()const
+    {
+        return threshold_;
+    }
+
+    bool divideByVolume()const
+    {
+        return divideByVolume_();
+    }
+
+    Mask getMask()
+    {
+        return includeMask_().getMask();
+    }
+
+    virtual
+    const processedRegFieldType& processedField()const=0;
+
+    virtual 
+    bool execute(const std::vector<span<real>>& weights) = 0;
+
+    virtual 
+    bool write(const fileSystem &parDir)const;
+
+    virtual 
+    bool write(iOstream& os)const {return true;}
+
+    static
+    uniquePtr<postprocessOperation> create(
+        const dictionary& opDict,
+        const regionPoints& regPoints,
+        fieldsDataBase& fieldsDB);
+    
+};
+
+}
+
+#endif //__postprocessOperation_hpp__