# PhasicFlow: utilities/postprocessPhasicFlow/ProcessField.hpp Source File
PhasicFlow is an open-source parallel DEM (discrete element method) package for simulating granular flow. It is developed in C++ and can be exectued on both GPU (like CUDA) and CPU.

ProcessField.hpp
Go to the documentation of this file.
/*------------------------------- 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 __ProcessField_hpp__
#define __ProcessField_hpp__
#include "processField.hpp"
#include "rectMeshFields.hpp"
#include "twoPartEntry.hpp"
#include "fieldOperations.hpp"
#include "rectMeshFieldToVTK.hpp"
namespace pFlow
{
template<typename T>
class ProcessField
:
public processField
{
protected:
uniquePtr<pointField_H<T>> field_;
rectMeshField_H<T> processedField_;
public:
TypeInfoTemplate11("ProcessField", T);
ProcessField(
const dictionary& dict,
pointRectCell& pToCell,
repository& rep)
:
processField(dict, pToCell, rep),
field_(
this->isUniform()?
timeFolder().createUniformPointField_H(this->fieldName(), getUniformValue(), false ):
timeFolder().readPointField_H<T>(this->fieldName())
),
processedField_
(
mesh(),
processedFieldName(),
T{}
)
{
}
add_vCtor(
processField,
ProcessField,
dictionary);
T getUniformValue()const
{
const dataEntry& entry = dict().dataEntryRef("field");
twoPartEntry tpEntry(entry);
return tpEntry.secondPartVal<T>();
}
virtual bool process() override
{
const includeMask& incMask = includeMask_();
auto numeratorPtr = sumMaksOp( field_() , this->pointToCell(), incMask);
uniquePtr<rectMeshField_H<real>> denomeratorPtr;
if(operation() == "sum")
{
denomeratorPtr = makeUnique<rectMeshField_H<real>>(this->mesh(), static_cast< real >(1.0));
}else if(operation() == "average")
{
pointField_H<real> oneFld(
objectFile
(
"oneField",
"",
objectFile::READ_NEVER,
objectFile::WRITE_NEVER
),
const_cast< pointStructure&>(field_().pStruct()),
static_cast< real >(1.0),
static_cast< real >(1.0)
);
denomeratorPtr = sumOp(oneFld, this->pointToCell());
}else if(operation() == "averageMask")
{
//pointField_H<real> oneFld(field_().pStruct(), static_cast<real>(1.0), static_cast<real>(1.0));
pointField_H<real> oneFld(
objectFile
(
"oneField",
"",
objectFile::READ_NEVER,
objectFile::WRITE_NEVER
),
const_cast< pointStructure&>(field_().pStruct()),
static_cast< real >(1.0),
static_cast< real >(1.0)
);
denomeratorPtr = sumMaksOp(oneFld, this->pointToCell(), incMask);
}
else
{
fatalErrorInFunction<<"operation is not known: "<< operation()<<endl;
fatalExit;
}
auto& numerator = numeratorPtr();
auto& denomerator = denomeratorPtr();
for(int32 i=0; i<this->mesh().nx(); i++ )
{
for(int32 j=0; j<this->mesh().ny(); j++ )
{
for(int32 k=0; k<this->mesh().nz(); k++ )
{
if( pointToCell().nPointInCell(i,j,k)>= threshold() )
{
processedField_(i,j,k) = numerator(i,j,k)/denomerator(i,j,k);
}
else
{
processedField_(i,j,k) = T{};
}
}
}
}
return true;
}
bool writeToVTK(iOstream& os)const override
{
return convertRectMeshField(os, processedField_);
}
};
} // pFlow
#endif //__ProcessField_hpp__
twoPartEntry.hpp
pFlow::ProcessField::field_
uniquePtr< pointField_H< T > > field_
Definition: ProcessField.hpp:43
pFlow::real
float real
Definition: builtinTypes.hpp:45
fatalExit
#define fatalExit
Fatal exit.
Definition: error.hpp:98
pFlow::rectMeshField
Definition: rectMeshField.hpp:31
pFlow::twoPartEntry
Definition: twoPartEntry.hpp:36
pFlow::sumMaksOp
uniquePtr< rectMeshField_H< T > > sumMaksOp(pointField_H< T > &field, pointRectCell &pointToCell, const incMask &mask)
Definition: fieldOperations.hpp:66
pFlow::processField::isUniform
bool isUniform() const
Definition: processField.hpp:134
pFlow::processField::processedFieldName
const word & processedFieldName() const
Definition: processField.hpp:159
fieldOperations.hpp
pFlow::endl
iOstream & endl(iOstream &os)
Add newline and flush stream.
Definition: iOstream.hpp:341
pFlow::includeMask
Definition: includeMask.hpp:33
pFlow::processField::operation
const word & operation() const
Definition: processField.hpp:139
pFlow::processField::includeMask_
uniquePtr< includeMask > includeMask_
Definition: processField.hpp:59
pFlow::ProcessField::processedField_
rectMeshField_H< T > processedField_
Definition: ProcessField.hpp:46
pFlow
Definition: demGeometry.hpp:27
pFlow::ProcessField::add_vCtor
add_vCtor(processField, ProcessField, dictionary)
pFlow::objectFile::WRITE_NEVER
@ WRITE_NEVER
Definition: objectFile.hpp:44
pFlow::pointField
Definition: pointField.hpp:33
pFlow::pointStructure
Definition: pointStructure.hpp:34
pFlow::ProcessField::writeToVTK
bool writeToVTK(iOstream &os) const override
Definition: ProcessField.hpp:167
pFlow::dataEntry
Data entry to be used in dictionries.
Definition: dataEntry.hpp:48
processField.hpp
fatalErrorInFunction
#define fatalErrorInFunction
Report a fatal error and function name and exit the application.
Definition: error.hpp:77
pFlow::int32
int int32
Definition: builtinTypes.hpp:50
pFlow::pointRectCell
Definition: pointRectCell.hpp:32
pFlow::convertRectMeshField
bool convertRectMeshField(iOstream &os, const rectMeshField_H< T > &field)
Definition: rectMeshFieldToVTK.hpp:29
pFlow::processField::processField
processField(const dictionary &dict, pointRectCell &pToCell, repository &rep)
Definition: processField.cpp:27
rectMeshFields.hpp
pFlow::objectFile
Definition: objectFile.hpp:30
pFlow::processField
Definition: processField.hpp:37
pStruct
auto & pStruct
Definition: setPointStructure.hpp:24
pFlow::ProcessField::ProcessField
ProcessField(const dictionary &dict, pointRectCell &pToCell, repository &rep)
Definition: ProcessField.hpp:52
pFlow::ProcessField::process
virtual bool process() override
Definition: ProcessField.hpp:86
pFlow::objectFile::READ_NEVER
@ READ_NEVER
Definition: objectFile.hpp:37
pFlow::ProcessField::getUniformValue
T getUniformValue() const
Definition: ProcessField.hpp:79
pFlow::uniquePtr
Definition: uniquePtr.hpp:42
pFlow::processField::threshold
auto threshold() const
Definition: processField.hpp:154
pFlow::processField::fieldName
const word & fieldName() const
Definition: processField.hpp:129
pFlow::repository
Definition: repository.hpp:34
pFlow::sumOp
uniquePtr< rectMeshField_H< T > > sumOp(pointField_H< T > &field, pointRectCell &pointToCell)
Definition: fieldOperations.hpp:34
pFlow::processField::mesh
const auto & mesh() const
Definition: processField.hpp:84
rectMeshFieldToVTK.hpp
pFlow::ProcessField::TypeInfoTemplate11
TypeInfoTemplate11("ProcessField", T)
pFlow::processField::dict
auto & dict()
Definition: processField.hpp:104
pFlow::iOstream
Interface class for any output stream.
Definition: iOstream.hpp:59
pFlow::dictionary
Dictionary holds a set of data entries or sub-dictionaries that are enclosed in a curely braces or ar...
Definition: dictionary.hpp:67
pFlow::ProcessField
Definition: ProcessField.hpp:36
pFlow::twoPartEntry::secondPartVal
T secondPartVal() const
Definition: twoPartEntry.hpp:62
pFlow::processField::pointToCell
const auto & pointToCell() const
Definition: processField.hpp:94
pFlow::timeFolder
Definition: timeFolder.hpp:32