327 lines
9.0 KiB
C++
327 lines
9.0 KiB
C++
/*------------------------------- 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 __fieldsDataBase_hpp__
|
|
#define __fieldsDataBase_hpp__
|
|
|
|
#include "fieldsDataBaseDclr.hpp"
|
|
|
|
#include "pointStructure.hpp"
|
|
#include "pointFields.hpp"
|
|
#include "anyList.hpp"
|
|
#include "Map.hpp"
|
|
#include "shape.hpp"
|
|
|
|
namespace pFlow
|
|
{
|
|
class dictionary;
|
|
class systemControl;
|
|
class Time;
|
|
}
|
|
|
|
namespace pFlow::postprocessData
|
|
{
|
|
|
|
|
|
class fieldsDataBase
|
|
{
|
|
private:
|
|
|
|
// - Typedefs
|
|
|
|
/// Point position data type
|
|
using PointsTypeHost = typename pointStructure::PointsTypeHost;
|
|
|
|
/// Point field data type
|
|
template<typename T>
|
|
using FieldTypeHost = typename internalField<T>::FieldTypeHost;
|
|
|
|
/// @brief Enumeration of functions that can be applied to point fields.
|
|
enum class Functions
|
|
{
|
|
None, /// no function
|
|
ComponentX, /// component(u,x)
|
|
ComponentY, /// component(u,y)
|
|
ComponentZ, /// component(u,z)
|
|
ComponentW, /// component(u,w)
|
|
Abs, /// abs(s)
|
|
Square, /// square(s)
|
|
Cube, /// cube(s)
|
|
SqureRoot, /// sqrt(s)
|
|
Magnitude, /// mag(u)
|
|
MagnitudeSquare, /// magSquare(u)
|
|
MagnitudeCube, /// magCube(u)
|
|
MagnitudeSquareRoot /// magSqrt(u)
|
|
};
|
|
|
|
|
|
// - Member variables
|
|
|
|
/// List to store all the point fields
|
|
anyList allFields_;
|
|
|
|
/// Map to store the last capture time of each field
|
|
wordMap<timeValue> captureTime_;
|
|
|
|
/// Reference to the Time object
|
|
Time& time_;
|
|
|
|
/// Flag indicating if we're in simulation mode
|
|
bool inSimulation_ = false;
|
|
|
|
word shapeType_;
|
|
|
|
protected:
|
|
|
|
/// check if pointField name exists in Time or time folder
|
|
virtual
|
|
bool pointFieldNameExists(const word& name)const = 0;
|
|
|
|
/// Loads a pointField with a given name to the Time object
|
|
virtual
|
|
bool loadPointFieldToTime(const word& name)= 0;
|
|
|
|
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
|
|
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);
|
|
|
|
template<ValidFieldType T>
|
|
span<T> updateReservedField(const word& name, bool forceUpdate = false);
|
|
|
|
span<real> createOrGetRealField(const word& name);
|
|
|
|
span<real> createOrGetVolume(bool forceUpdate=false);
|
|
|
|
span<real> createOrGetDensity(bool forceUpdate=false);
|
|
|
|
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,
|
|
word& fieldName,
|
|
fieldsDataBase::Functions& func );
|
|
|
|
static
|
|
bool inputOutputType(
|
|
fieldsDataBase::Functions func,
|
|
const word& inputType,
|
|
word& outputType);
|
|
|
|
|
|
|
|
public:
|
|
|
|
// - Type info
|
|
|
|
TypeInfo("fieldsDataBase");
|
|
|
|
// - constructors
|
|
|
|
fieldsDataBase(
|
|
systemControl& control,
|
|
const dictionary& postDict,
|
|
bool inSimulation,
|
|
timeValue startTime);
|
|
|
|
/// no copy constructor
|
|
fieldsDataBase(const fieldsDataBase&) = delete;
|
|
|
|
/// no move constructor
|
|
fieldsDataBase(fieldsDataBase&&) = delete;
|
|
|
|
/// no copy assignment
|
|
fieldsDataBase& operator=(const fieldsDataBase&) = delete;
|
|
|
|
/// no move assignment
|
|
fieldsDataBase& operator=(fieldsDataBase&&) = delete;
|
|
|
|
/// destructor
|
|
virtual ~fieldsDataBase() = default;
|
|
|
|
create_vCtor
|
|
(
|
|
fieldsDataBase,
|
|
bool,
|
|
(
|
|
systemControl& control,
|
|
const dictionary& postDict,
|
|
bool inSimulation,
|
|
timeValue startTime
|
|
),
|
|
(control, postDict, inSimulation, startTime)
|
|
);
|
|
|
|
|
|
// - Public Access Functions
|
|
/// returns the current time
|
|
timeValue currentTime()const;
|
|
|
|
/// const ref to object Time
|
|
const Time& time()const
|
|
{
|
|
return time_;
|
|
}
|
|
|
|
Time& time()
|
|
{
|
|
return time_;
|
|
}
|
|
|
|
// - Public Member Functions
|
|
|
|
bool getFieldTypeNameFunction
|
|
(
|
|
const word& compoundName,
|
|
word& pointFieldName,
|
|
word& originalType,
|
|
word& typeAfterFunction,
|
|
Functions& func
|
|
)const;
|
|
|
|
|
|
bool getFieldType
|
|
(
|
|
const word& compoundName,
|
|
word& originalType,
|
|
word& typeAfterFunction
|
|
) const;
|
|
|
|
bool getFieldType
|
|
(
|
|
const word& compoundName,
|
|
word& typeAfterFunction
|
|
) const;
|
|
|
|
|
|
/// update pointStructure if necessary
|
|
span<realx3> updatePoints(bool forceUpdate = false);
|
|
|
|
/// update a field with realx3 type
|
|
span<realx3> updateFieldRealx3(
|
|
const word& compoundName,
|
|
bool forceUpdate = false);
|
|
|
|
span<realx4> updateFieldRealx4(
|
|
const word& compoundName,
|
|
bool forceUpdate = false);
|
|
|
|
span<real> updateFieldReal(
|
|
const word& compoundName,
|
|
bool forceUpdate = false);
|
|
|
|
span<uint32> updateFieldUint32(
|
|
const word& name,
|
|
bool forceUpdate = false);
|
|
|
|
/// Updates and retrieves a point field of any type from the database.
|
|
/// It returns types real, realx3 and realx4 only.
|
|
allPointFieldTypes updateFieldAll(
|
|
const word& compoundName,
|
|
bool forceUpdate = false);
|
|
|
|
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
|
|
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
|
|
bool pointFieldGetType(
|
|
const word& TYPENAME,
|
|
word& fieldType,
|
|
word& fieldSpace);
|
|
|
|
static
|
|
uniquePtr<fieldsDataBase> create(
|
|
systemControl& control,
|
|
const dictionary& postDict,
|
|
bool inSimulation,
|
|
timeValue startTime);
|
|
};
|
|
|
|
} // namespace pFlow::postprocessData
|
|
|
|
#include "fieldsDataBaseTemplates.cpp"
|
|
|
|
#endif //__fieldsDataBased_hpp__
|