# PhasicFlow: src/Particles/Insertion/insertion/insertion.cpp 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.

insertion.cpp
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.
-----------------------------------------------------------------------------*/
#include "insertion.hpp"
#include "particles.hpp"
#include "streams.hpp"
#include "systemControl.hpp"
#include "vocabs.hpp"
pFlow::insertion::insertion(particles& prtcl)
: fileDictionary(
objectFile(
insertionFile__,
"",
objectFile::READ_IF_PRESENT,
objectFile::WRITE_ALWAYS
),
&prtcl.time()
),
particles_(prtcl)
{
// this means that insertion file exist in time folder
if( IOobject::implyRead() )
{
readFromFile_ = true;
} // look inside the caseSetup folder if it exist
else
{
// read dictionary from caseSetup folder
fileDictionary caseFile(
objectFile(
insertionFile__,
"",
objectFile::READ_IF_PRESENT,
objectFile::WRITE_NEVER),
&prtcl.control().caseSetup());
// check if read happened
if(caseFile.implyRead())
{
readFromFile_ = true;
// assign it to this dictionary
fileDictionary::dictionary::operator=(caseFile);
}
}
if( readFromFile_)
{
readInsertionDict();
}
}
const pFlow::pointStructure&
pFlow::insertion::pStruct() const
{
return particles_.pStruct();
}
bool
pFlow::insertion::readInsertionDict()
{
active_ = getVal<Logical>("active");
if (active_)
{
checkForCollision_ = getVal<Logical>("checkForCollision");
REPORT(1) << "Particle insertion mechanism is " << Yellow_Text("active")
<< " in the simulation." << END_REPORT;
}
else
{
REPORT(1) << "Particle insertion mechanism is "
<< Yellow_Text("not active") << " in the simulation."
<< END_REPORT;
}
return true;
}
bool
pFlow::insertion::writeInsertionDict(dictionary& dict) const
{
if (!dict.add("active", active_))
{
fatalErrorInFunction <<"Error in writing active to dictionary "
<<dict.globalName()<<endl;
return false;
}
if (!dict.add("checkForCollision", checkForCollision_))
{
fatalErrorInFunction <<
"Error in writing checkForCollision to dictionary "<<
dict.globalName()<<endl;
return false;
}
return true;
}
bool pFlow::insertion::write(iOstream & os, const IOPattern & iop) const
{
dictionary newDict(fileDictionary::dictionary::name(), true);
if( iop.thisProcWriteData() )
{
if( !writeInsertionDict(newDict) ||
!newDict.write(os))
{
fatalErrorInFunction<<
" error in writing to dictionary "<< newDict.globalName()<<endl;
return false;
}
}
return true;
}
/*bool
pFlow::insertion::read(iIstream& is, const IOPattern& iop)
{
if (fileDictionary::read(is, iop))
{
readFromFile_ = true;
return true;
}
else
{
return false;
}
}*/
pFlow::insertion::pStruct
const pointStructure & pStruct() const
Definition: insertion.cpp:72
pFlow::objectFile::objectFile
objectFile(const word &name)
Definition: objectFile.cpp:24
pFlow::demComponent::control
const auto & control() const
Const ref to systemControl.
Definition: demComponent.hpp:88
REPORT
#define REPORT(n)
Definition: streams.hpp:39
systemControl.hpp
insertion.hpp
pFlow::dictionary::globalName
virtual word globalName() const
global name of entry, separated with dots
Definition: dictionary.cpp:356
particles.hpp
pFlow::dictionary::add
bool add(const word &keyword, const float &v)
add a float dataEntry
Definition: dictionary.cpp:435
pFlow::endl
iOstream & endl(iOstream &os)
Add newline and flush stream.
Definition: iOstream.hpp:341
pFlow::insertionFile__
const char *const insertionFile__
Definition: vocabs.hpp:40
Yellow_Text
#define Yellow_Text(text)
Definition: iOstream.hpp:40
pFlow::objectFile::WRITE_NEVER
@ WRITE_NEVER
Definition: objectFile.hpp:44
pFlow::pointStructure
Definition: pointStructure.hpp:34
pFlow::particles
Definition: particles.hpp:33
fatalErrorInFunction
#define fatalErrorInFunction
Report a fatal error and function name and exit the application.
Definition: error.hpp:77
pFlow::insertion::readFromFile_
bool readFromFile_
Definition: insertion.hpp:58
pFlow::insertion::insertion
insertion(particles &prtcl)
Construct from component.
Definition: insertion.cpp:27
pFlow::insertion::writeInsertionDict
virtual bool writeInsertionDict(dictionary &dict) const
Write to dictionary.
Definition: insertion.cpp:99
pFlow::IOPattern
Definition: IOPattern.hpp:32
pFlow::dictionary::write
bool write(iOstream &os) const override
write to stream
Definition: dictionary.cpp:793
pFlow::IOPattern::thisProcWriteData
bool thisProcWriteData() const
Definition: IOPattern.hpp:146
END_REPORT
#define END_REPORT
Definition: streams.hpp:40
pFlow::objectFile
Definition: objectFile.hpp:30
streams.hpp
pFlow::IOfileHeader::implyRead
bool implyRead() const
Imply read.
Definition: IOfileHeader.cpp:121
pFlow::fileDictionary
Definition: fileDictionary.hpp:29
pFlow::objectFile::READ_IF_PRESENT
@ READ_IF_PRESENT
Definition: objectFile.hpp:38
vocabs.hpp
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::insertion::write
bool write(iOstream &os, const IOPattern &iop) const override
write to iOstream
Definition: insertion.cpp:120
pFlow::insertion::readInsertionDict
bool readInsertionDict()
Read from dictionary.
Definition: insertion.cpp:78