postprocessPhasicFlow is now updated with new postprocessData auxFunction. It now uses postprocessDataDict.

2025-06-22 16:28:30 +00:00 · 2025-04-21 00:13:54 +03:30
parent 40deb1f9c0
commit 9de1fa2dc7
41 changed files with 1000 additions and 2912 deletions
--- a/src/PostprocessData/fieldsDataBase/fieldsDataBase.cpp
+++ b/src/PostprocessData/fieldsDataBase/fieldsDataBase.cpp
@ -24,7 +24,7 @@ Licence:
 #include "systemControl.hpp"
 #include "fieldsDataBase.hpp"
 #include "fieldFunctions.hpp"
-
+#include "dictionary.hpp"

 namespace pFlow
 {
@ -38,19 +38,6 @@ bool pFlow::fieldsDataBase::loadPointStructureToTime()
    return false;
 }

-pFlow::word pFlow::fieldsDataBase::getPointFieldType(const word &name) const
-{
-    word pfType =  time_.lookupObjectTypeName(name);
-    word type, space;
-    if(!pointFieldGetType(pfType, type, space))
-    {
-        fatalErrorInFunction
-            <<"Error in retriving the type of pointField "
-            << pfType<<endl;
-        fatalExit;
-    }
-    return type;
-}

 bool pFlow::fieldsDataBase::checkForUpdate(const word &compoundName, bool forceUpdate)
 {
@ -195,6 +182,78 @@ pFlow::span<pFlow::real> pFlow::fieldsDataBase::createOrGetOne(bool forceUpdate)
        field.size());
 }

+pFlow::span<pFlow::real> pFlow::fieldsDataBase::createOrGetMass(bool forceUpdate)
+{
+    const word fName = "mass";
+    
+    bool shouldUpdate = checkForUpdate(fName, forceUpdate);
+
+    if(shouldUpdate)
+    {
+        const auto index = updateFieldUint32("shapeIndex", true);
+        const auto ms = getShape().mass();
+
+        FieldTypeHost<real> massField
+        (
+            fName, 
+            "value",
+            pointFieldSize()
+        );
+
+        for(uint32 i=0; i< massField.size(); i++)
+        {
+            massField[i] = ms[index[i]];
+        }
+
+        allFields_.emplaceBackOrReplace<FieldTypeHost<real>>
+        (
+            fName,
+            std::move(massField)  
+        );
+    }
+
+    auto& field = allFields_.getObject<FieldTypeHost<real>>(fName);
+    return span<real>(
+        field.data(), 
+        field.size());
+}
+
+pFlow::span<pFlow::real> pFlow::fieldsDataBase::createOrGetI(bool forceUpdate)
+{
+    const word fName = "I";
+    
+    bool shouldUpdate = checkForUpdate(fName, forceUpdate);
+
+    if(shouldUpdate)
+    {
+        const auto index = updateFieldUint32("shapeIndex", true);
+        const auto Is = getShape().Inertia();
+
+        FieldTypeHost<real> IField
+        (
+            fName, 
+            "value",
+            pointFieldSize()
+        );
+
+        for(uint32 i=0; i< IField.size(); i++)
+        {
+            IField[i] = Is[index[i]];
+        }
+
+        allFields_.emplaceBackOrReplace<FieldTypeHost<real>>
+        (
+            fName,
+            std::move(IField)  
+        );
+    }
+
+    auto& field = allFields_.getObject<FieldTypeHost<real>>(fName);
+    return span<real>(
+        field.data(), 
+        field.size());
+}
+
 bool pFlow::fieldsDataBase::findFunction(
    const word &compoundFieldName,
    word &fieldName,
@ -399,11 +458,35 @@ bool pFlow::fieldsDataBase::inputOutputType
    return false;
 }

-pFlow::fieldsDataBase::fieldsDataBase(systemControl& control, bool inSimulation)
+pFlow::fieldsDataBase::fieldsDataBase
+(
+    systemControl& control,
+    const dictionary& postDict,
+    bool inSimulation,
+    timeValue startTime
+)
 :
    time_(control.time()),
    inSimulation_(inSimulation)
-{}
+{
+    if(!inSimulation_)
+    {
+        shapeType_ = postDict.getValOrSet<word>("shapeType", "");
+
+        if(shapeType_.empty())
+        {
+            WARNING
+            << "shapeType is not set in dictionary: "
+            << postDict.globalName()
+            << " and you may need to set for some postprocess operations"<<END_WARNING;
+        }
+    }
+    else
+    {
+        // this is not required for execution during simulation 
+        shapeType_ = "";
+    }
+}

 pFlow::timeValue pFlow::fieldsDataBase::currentTime() const
 {
@ -808,7 +891,13 @@ pFlow::allPointFieldTypes pFlow::fieldsDataBase::updateFieldAll


 pFlow::uniquePtr<pFlow::fieldsDataBase> 
-    pFlow::fieldsDataBase::create(systemControl& control, bool inSimulation)
+    pFlow::fieldsDataBase::create
+(
+    systemControl& control, 
+    const dictionary& postDict, 
+    bool inSimulation,
+    timeValue startTime
+)
 {
    word dbType;
    if(inSimulation)
@ -823,7 +912,7 @@ pFlow::uniquePtr<pFlow::fieldsDataBase>
    if( boolvCtorSelector_.search(dbType) )
    {
        auto objPtr = 
-            boolvCtorSelector_[dbType](control, inSimulation);
+            boolvCtorSelector_[dbType](control, postDict, inSimulation, startTime);
        return objPtr;
    }
    else
--- a/src/PostprocessData/fieldsDataBase/fieldsDataBase.hpp
+++ b/src/PostprocessData/fieldsDataBase/fieldsDataBase.hpp
@ -33,6 +33,7 @@ Licence:
 namespace pFlow
 {

+class dictionary;
 class systemControl;
 class Time;

@ -83,16 +84,9 @@ private:
        /// Flag indicating if we're in simulation mode
        bool                inSimulation_ = false;

-protected:
+        word                shapeType_;

-        /// Map of reserved field names with their corresponding types
-        static const inline std::map<word, word> reservedFieldNames_
-        {
-            {"position", "realx3"},
-            {"one", "real"},
-            {"volume", "real"},
-            {"density", "real"}
-        };
+protected:

        /// check if pointField name exists in Time or time folder 
        virtual 
@ -104,12 +98,28 @@ protected:

        virtual 
        bool loadPointStructureToTime()=0;
+        
+        virtual 
+        const shape& getShape() const= 0;
+
+        const word& shapeTypeName()const
+        {
+            return shapeType_;
+        }

        /// get the type name of the pointField in the Time object 
-        word getPointFieldType(const word& name)const;
+        virtual 
+        word getPointFieldType(const word& name)const = 0;

        /// Checks if a field needs to be updated based on capture time
        bool checkForUpdate(const word& compoundName, bool forceUpdate = false);
+    
+        /// @brief return the size of pointStructure 
+        uint32 pointFieldSize()
+        {
+            auto s = updatePoints();
+            return s.size();
+        }

        template<ValidFieldType T>
        span<T> updateField(const word& name, bool forceUpdate = false);
@ -125,6 +135,21 @@ protected:

        span<real> createOrGetOne(bool forceUpdate=false);

+        span<real> createOrGetMass(bool forceUpdate=false);
+
+        span<real> createOrGetI(bool forceUpdate=false);
+
+        /// Map of reserved field names with their corresponding types
+        static const inline std::map<word, word> reservedFieldNames_
+        {
+            {"position", "realx3"},
+            {"one", "real"},
+            {"volume", "real"},
+            {"density", "real"},
+            {"mass", "real"},
+            {"I", "real"}
+        };
+        
        static 
        bool findFunction(
            const word& compoundFieldName, 
@ -137,25 +162,7 @@ protected:
            const word& inputType, 
            word& outputType);

-
-protected:
    
-    // - protected member functions
-    
-
-    virtual 
-    bool checkTimeFolder(const word& fieldName) const = 0;
-    
-    virtual 
-    const shape& getShape() const= 0;
-
-
-    /// @brief return the size of pointStructure 
-    uint32 pointFieldSize()
-    {
-        auto s = updatePoints();
-        return s.size();
-    }

 public:
    
@ -165,7 +172,11 @@ public:

    // - constructors 

-        fieldsDataBase(systemControl& control, bool inSimulation);
+        fieldsDataBase(
+            systemControl& control, 
+            const dictionary& postDict,
+            bool inSimulation,
+            timeValue startTime);

        /// no copy constructor
        fieldsDataBase(const fieldsDataBase&) = delete;
@ -186,8 +197,13 @@ public:
        (
            fieldsDataBase,
            bool,
-            (systemControl& control, bool inSimulation),
-            (control, inSimulation)
+            (
+                systemControl& control, 
+                const dictionary& postDict, 
+                bool inSimulation,
+                timeValue startTime
+            ),
+            (control, postDict, inSimulation, startTime)
        );
  
    
@ -260,14 +276,39 @@ public:
        
        virtual 
        const pointStructure& pStruct()const = 0;
+        
+        /// Get the next avaiable time folder after the current time folder 
+        /// This is only used for post-simulation processing 
+        virtual
+        timeValue getNextTimeFolder()const
+        {
+            return -1.0;
+        }

+        /// Sets the current folder to the next time folder.
+        /// This is used only for post-simulation processing
+        /// @returns the time value of the next folder.
        virtual 
-        void resetTimeFolder() = 0;
-    
+        timeValue setToNextTimeFolder()
+        {
+            return -1.0;
+        }
+        
+        /// Skips the next time folder.
+        /// This is used only for post-simulation processing 
+        /// @returns the time value of the skipped folder 
+        virtual 
+        timeValue skipNextTimeFolder()
+        {
+            return -1.0;
+        }
+
    static
    uniquePtr<fieldsDataBase> create(
        systemControl& control, 
-        bool inSimulation);
+        const dictionary& postDict, 
+        bool inSimulation,
+        timeValue startTime);
 };

 } // namespace pFlow
--- a/src/PostprocessData/fieldsDataBase/fieldsDataBaseTemplates.cpp
+++ b/src/PostprocessData/fieldsDataBase/fieldsDataBaseTemplates.cpp
@ -116,6 +116,36 @@ pFlow::span<T> pFlow::fieldsDataBase::updateReservedField
            fatalExit;
        }
    }
+    else if( name == "mass")
+    {
+        if constexpr( std::same_as<T,real>)
+        {
+            return createOrGetMass(forceUpdate);
+        }
+        else
+        {
+            fatalErrorInFunction
+                << "This type: "
+                << getTypeName<T>()
+                <<" is not supported for field mass."<<endl;
+            fatalExit;
+        }
+    }
+    else if( name == "I")
+    {
+        if constexpr( std::same_as<T,real>)
+        {
+            return createOrGetI(forceUpdate);
+        }
+        else
+        {
+            fatalErrorInFunction
+                << "This type: "
+                << getTypeName<T>()
+                <<" is not supported for field I."<<endl;
+            fatalExit;
+        }
+    }
    else if( name == "position")
    {
        if constexpr( std::same_as<T, realx3>)
--- a/src/PostprocessData/fieldsDataBase/simulationFieldsDataBase.cpp
+++ b/src/PostprocessData/fieldsDataBase/simulationFieldsDataBase.cpp
@ -24,23 +24,35 @@ bool pFlow::simulationFieldsDataBase::loadPointStructureToTime()
    return time().lookupObjectName(pointStructureFile__);
 }

-bool pFlow::simulationFieldsDataBase::checkTimeFolder(const word &fieldName) const
-{
-    return true;
-}

 const pFlow::shape& pFlow::simulationFieldsDataBase::getShape() const
 {
    return shape_;
 }

+pFlow::word pFlow::simulationFieldsDataBase::getPointFieldType(const word &name) const
+{
+    word pfType =  time().lookupObjectTypeName(name);
+    word type, space;
+    if(!pointFieldGetType(pfType, type, space))
+    {
+        fatalErrorInFunction
+            <<"Error in retriving the type of pointField "
+            << pfType<<endl;
+        fatalExit;
+    }
+    return type;
+}
+
 pFlow::simulationFieldsDataBase::simulationFieldsDataBase
 (
-    systemControl &control, 
-    bool inSimulation
+    systemControl &control,
+    const dictionary& postDict, 
+    bool inSimulation,
+    timeValue startTime
 )
 :
-    fieldsDataBase(control, inSimulation),
+    fieldsDataBase(control, postDict, inSimulation, startTime),
    shape_
    (
        dynamic_cast<const shape&>(*control.caseSetup().lookupObjectPtr(shapeFile__))
@ -57,6 +69,3 @@ const pFlow::pointStructure &pFlow::simulationFieldsDataBase::pStruct() const
    );
 }

-void pFlow::simulationFieldsDataBase::resetTimeFolder()
-{
-}
--- a/src/PostprocessData/fieldsDataBase/simulationFieldsDataBase.hpp
+++ b/src/PostprocessData/fieldsDataBase/simulationFieldsDataBase.hpp
@ -38,6 +38,7 @@ protected:
    
    /// check if pointField name exists in Time or time folder 
    bool pointFieldNameExists(const word& name)const override;
+ 

    /// Loads a pointField with a given name to the Time object. 
    /// For simulation, it just checks if the name exists 
@ -47,15 +48,19 @@ protected:
    /// For simulation, it just checks if the name exists
    bool loadPointStructureToTime() override;

-    bool checkTimeFolder(const word& fieldName) const override;
-
    const shape& getShape() const override;  
+
+    word getPointFieldType(const word& name)const override;
    
 public:

    TypeInfo("fieldsDataBase<simulation>");

-    simulationFieldsDataBase(systemControl& control, bool inSimulation);
+    simulationFieldsDataBase(
+        systemControl& control, 
+        const dictionary& postDict,
+        bool inSimulation,
+        timeValue startTime);

    ~simulationFieldsDataBase() override = default;

@ -68,8 +73,6 @@ public:

    const pointStructure& pStruct()const override;

-    void resetTimeFolder() override;
-
 };