# PhasicFlow: utilities/postprocessPhasicFlow/ProcessField.hpp Source File

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:
pointField_H<T>& field_;
rectMeshField_H<T>& processedField_;
public:
TypeInfoTemplate("ProcessField", T);
ProcessField(
const dictionary& dict,
pointRectCell& pToCell,
repository& rep)
:
processField(dict, pToCell, rep),
field_(
this->isUniform()?
timeFolder().createUniformPointField_H(this->fieldName(), getUniformValue() ):
timeFolder().readPointField_H<T>(this->fieldName())
),
processedField_
(
processedRepository().emplaceObject<rectMeshField_H<T>>
(
objectFile
(
processedFieldName(),
"",
objectFile::READ_NEVER,
objectFile::WRITE_ALWAYS
),
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 numerator = sumMaksOp( field_ , this->pointToCell(), incMask);
rectMeshField_H<real> denomerator( this->mesh(), real{} );
if(operation() == "sum")
{
denomerator = rectMeshField_H<real>(this->mesh(), static_cast< real >(1.0));
}else if(operation() == "average")
{
pointField_H<real> oneFld(field_.pStruct(), static_cast< real >(1.0), static_cast< real >(1.0));
denomerator = sumOp(oneFld, this->pointToCell());
}else if(operation() == "averageMask")
{
pointField_H<real> oneFld(field_.pStruct(), static_cast< real >(1.0), static_cast< real >(1.0));
denomerator = sumMaksOp(oneFld, this->pointToCell(), incMask);
}else
{
fatalErrorInFunction<<"operation is not known: "<< operation()<<endl;
fatalExit;
}
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_
pointField_H< T > & field_
Definition: ProcessField.hpp:43
pFlow::real
float real
Definition: builtinTypes.hpp:46
fatalExit
#define fatalExit
Definition: error.hpp:57
pFlow::rectMeshField
Definition: rectMeshField.hpp:31
pFlow::twoPartEntry
Definition: twoPartEntry.hpp:36
pFlow::processField::isUniform
bool isUniform() const
Definition: processField.hpp:123
pFlow::processField::processedFieldName
const word & processedFieldName() const
Definition: processField.hpp:148
fieldOperations.hpp
pFlow::endl
iOstream & endl(iOstream &os)
Definition: iOstream.hpp:312
pFlow::includeMask
Definition: includeMask.hpp:33
pFlow::processField::operation
const word & operation() const
Definition: processField.hpp:128
pFlow::processField::includeMask_
uniquePtr< includeMask > includeMask_
Definition: processField.hpp:59
pFlow
Definition: demComponent.hpp:28
pFlow::ProcessField::add_vCtor
add_vCtor(processField, ProcessField, dictionary)
pFlow::convertRectMeshField
bool convertRectMeshField(iOstream &os, rectMeshField_H< T > &field)
Definition: rectMeshFieldToVTK.hpp:29
pFlow::pointField
Definition: pointField.hpp:35
pFlow::ProcessField::writeToVTK
bool writeToVTK(iOstream &os) const override
Definition: ProcessField.hpp:152
pFlow::dataEntry
Definition: dataEntry.hpp:40
processField.hpp
fatalErrorInFunction
#define fatalErrorInFunction
Definition: error.hpp:42
pFlow::int32
int int32
Definition: builtinTypes.hpp:53
pFlow::sumOp
rectMeshField_H< T > sumOp(const pointField_H< T > field, const pointRectCell &pointToCell)
Definition: fieldOperations.hpp:34
pFlow::pointRectCell
Definition: pointRectCell.hpp:32
pFlow::processField::processField
processField(const dictionary &dict, pointRectCell &pToCell, repository &rep)
Definition: processField.cpp:27
rectMeshFields.hpp
pFlow::objectFile
Definition: objectFile.hpp:33
pFlow::processField
Definition: processField.hpp:37
pFlow::ProcessField::ProcessField
ProcessField(const dictionary &dict, pointRectCell &pToCell, repository &rep)
Definition: ProcessField.hpp:53
pFlow::ProcessField::process
virtual bool process() override
Definition: ProcessField.hpp:97
pFlow::ProcessField::TypeInfoTemplate
TypeInfoTemplate("ProcessField", T)
pFlow::processField::processedRepository
auto & processedRepository()
Definition: processField.hpp:108
pFlow::ProcessField::processedField_
rectMeshField_H< T > & processedField_
Definition: ProcessField.hpp:46
pFlow::ProcessField::getUniformValue
T getUniformValue() const
Definition: ProcessField.hpp:90
pFlow::sumMaksOp
rectMeshField_H< T > sumMaksOp(const pointField_H< T > field, const pointRectCell &pointToCell, const incMask &mask)
Definition: fieldOperations.hpp:65
pFlow::processField::threshold
auto threshold() const
Definition: processField.hpp:143
pFlow::processField::fieldName
const word & fieldName() const
Definition: processField.hpp:118
pFlow::repository
Definition: repository.hpp:34
pFlow::processField::mesh
const auto & mesh() const
Definition: processField.hpp:83
rectMeshFieldToVTK.hpp
pFlow::processField::dict
auto & dict()
Definition: processField.hpp:93
pFlow::iOstream
Definition: iOstream.hpp:53
pFlow::dictionary
Definition: dictionary.hpp:38
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:88
pFlow::timeFolder
Definition: timeFolder.hpp:32