runTimeControl.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2015 OpenFOAM Foundation
9  Copyright (C) 2015-2021 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
11 License
12  This file is part of OpenFOAM.
13 
14  OpenFOAM is free software: you can redistribute it and/or modify it
15  under the terms of the GNU General Public License as published by
16  the Free Software Foundation, either version 3 of the License, or
17  (at your option) any later version.
18 
19  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22  for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26 
27 \*---------------------------------------------------------------------------*/
28 
29 #include "runTimeControl.H"
30 #include "dictionary.H"
31 #include "runTimeCondition.H"
32 #include "fvMesh.H"
33 #include "Time.H"
35 
36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
37 
38 namespace Foam
39 {
40 namespace functionObjects
41 {
42 namespace runTimeControls
43 {
45  addToRunTimeSelectionTable(functionObject, runTimeControl, dictionary);
46 }
47 }
48 }
49 
51 <
53 >
55 {
56  { satisfiedAction::ABORT, "abort"},
57  { satisfiedAction::END, "end"},
58  { satisfiedAction::SET_TRIGGER, "setTrigger"},
59 };
60 
61 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
62 
63 Foam::functionObjects::runTimeControls::runTimeControl::runTimeControl
64 (
65  const word& name,
66  const Time& runTime,
67  const dictionary& dict
68 )
69 :
71  conditions_(),
72  groupMap_(),
73  nWriteStep_(0),
74  writeStepI_(0),
75  satisfiedAction_(satisfiedAction::END),
76  triggerIndex_(labelMin),
77  active_(getObjectProperty(name, "active", true))
78 {
79  read(dict);
80 }
81 
82 
83 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
84 
86 (
87  const dictionary& dict
88 )
89 {
90  if (functionObject::postProcess)
91  {
92  Info<< "Deactivated " << name()
93  << " function object for post-processing"
94  << endl;
95 
96  return false;
97  }
98 
99 
101  {
102  const dictionary& conditionsDict = dict.subDict("conditions");
103  const wordList conditionNames(conditionsDict.toc());
104  conditions_.setSize(conditionNames.size());
105 
106  label uniqueGroupi = 0;
107  forAll(conditionNames, conditioni)
108  {
109  const word& conditionName = conditionNames[conditioni];
110  const dictionary& dict = conditionsDict.subDict(conditionName);
111 
112  conditions_.set
113  (
114  conditioni,
115  runTimeCondition::New(conditionName, obr_, dict, *this)
116  );
117 
118  label groupi = conditions_[conditioni].groupID();
119 
120  if (groupMap_.insert(groupi, uniqueGroupi))
121  {
122  ++uniqueGroupi;
123  }
124  }
125 
126  dict.readIfPresent("nWriteStep", nWriteStep_);
127 
128  // Check that some conditions are set
129  if (conditions_.empty())
130  {
131  Info<< type() << " " << name() << " output:" << nl
132  << " No conditions present" << nl
133  << endl;
134  }
135  else
136  {
137  // Check that at least one condition is active
138  bool check = false;
139  for (const auto& condition : conditions_)
140  {
141  if (condition.active())
142  {
143  check = true;
144  break;
145  }
146  }
147 
148  if (!check)
149  {
150  Info<< type() << " " << name() << " output:" << nl
151  << " All conditions are inactive" << nl
152  << endl;
153  }
154  }
155 
156  // Set the action to perform when all conditions are satisfied
157  // - set to end for backwards compatibility with v1806
158  satisfiedAction_ =
159  satisfiedActionNames.getOrDefault
160  (
161  "satisfiedAction",
162  dict,
163  satisfiedAction::END
164  );
165 
166  if (satisfiedAction_ == satisfiedAction::SET_TRIGGER)
167  {
168  triggerIndex_ = dict.get<label>("trigger");
169  }
170 
171  return true;
172  }
173 
174  return false;
175 }
176 
177 
179 {
180  if (!active_)
181  {
182  return true;
183  }
184 
185  Info<< type() << " " << name() << " output:" << nl;
186 
187  // IDs of satisfied conditions
188  DynamicList<label> IDs(conditions_.size());
189 
190  // Run stops only if all conditions within a group are satisfied
191  List<bool> groupSatisfied(groupMap_.size(), true);
192  List<bool> groupActive(groupMap_.size(), false);
193 
194  forAll(conditions_, conditioni)
195  {
196  runTimeCondition& condition = conditions_[conditioni];
197 
198  if (condition.active())
199  {
200  bool conditionSatisfied = condition.apply();
201 
202  label groupi = condition.groupID();
203 
204  auto conditionIter = groupMap_.cfind(groupi);
205 
206  if (!conditionIter.found())
207  {
209  << "group " << groupi << " not found in map"
210  << abort(FatalError);
211  }
212 
213  if (conditionSatisfied)
214  {
215  IDs.append(conditioni);
216 
217  groupActive[conditionIter()] = true;
218 
219  if (groupi == -1)
220  {
221  // Condition not part of a group - only requires this to be
222  // satisfied for completion flag to be set
223  groupSatisfied[conditionIter()] = true;
224  break;
225  }
226  }
227  else
228  {
229  groupSatisfied[conditionIter()] = false;
230  }
231  }
232  }
233 
234  bool done = false;
235  forAll(groupSatisfied, groupi)
236  {
237  if (groupSatisfied[groupi] && groupActive[groupi])
238  {
239  done = true;
240  break;
241  }
242  }
243 
244  if (done)
245  {
246  for (label conditioni : IDs)
247  {
248  Info<< " " << conditions_[conditioni].type() << ": "
249  << conditions_[conditioni].name()
250  << " condition satisfied" << nl;
251  }
252 
253  switch (satisfiedAction_)
254  {
257  {
258  // Set to write a data dump or finalise the calculation
259  Time& time = const_cast<Time&>(time_);
260 
261  if (writeStepI_ < nWriteStep_ - 1)
262  {
263  ++writeStepI_;
264  Info<< " Writing fields - step " << writeStepI_ << nl;
265  time.writeNow();
266  }
267  else
268  {
269  Info<< " Stopping calculation" << nl
270  << " Writing fields";
271 
272  if (nWriteStep_ != 0)
273  {
274  Info<< " - final step" << nl;
275  }
276  else
277  {
278  Info<< nl;
279  }
280 
281  Info<< endl;
282  active_ = false;
283 
284  // Write any registered objects and set the end-time
285  time.writeAndEnd();
286 
287  // Trigger any function objects
288  time.run();
289 
290  if (satisfiedAction_ == satisfiedAction::ABORT)
291  {
293  << "Abort triggered"
294  << exit(FatalError);
295  }
296  }
297  break;
298  }
300  {
301  Info<< " Setting trigger " << triggerIndex_ << nl;
302  setTrigger(triggerIndex_);
303 
304  // Deactivate the model
305  active_ = false;
306  setProperty("active", active_);
307  break;
308  }
309  }
310  }
311  else
312  {
313  Info<< " Conditions not met" << nl;
314  }
315 
316  Info<< endl;
317 
318  return true;
319 }
320 
321 
323 {
324  for (auto& condition : conditions_)
325  {
326  condition.write();
327  }
328 
329  return true;
330 }
331 
332 
333 // ************************************************************************* //
Foam::functionObjects::runTimeControls::defineTypeNameAndDebug
defineTypeNameAndDebug(averageCondition, 0)
runTime
engineTime & runTime
Definition: createEngineTime.H:13
Foam::Enum
Enum is a wrapper around a list of names/values that represent particular enumeration (or int) values...
Definition: IOstreamOption.H:57
Foam::functionObjects::runTimeControls::runTimeCondition
Base class for run time conditions.
Definition: runTimeCondition.H:61
Foam::functionObjects::runTimeControls::runTimeControl::satisfiedAction::END
"end" - write and exit cleanly
Foam::Time
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:73
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:65
Foam::functionObjects::runTimeControls::runTimeControl::satisfiedAction::SET_TRIGGER
"setTrigger" - trigger another condition
Foam::DynamicList< label >
runTimeControl.H
Foam::functionObjects::timeFunctionObject::time_
const Time & time_
Reference to the time database.
Definition: timeFunctionObject.H:65
Foam::functionObjects::runTimeControls::runTimeControl::satisfiedActionNames
static Enum< satisfiedAction > satisfiedActionNames
Definition: runTimeControl.H:83
Foam::functionObjects::runTimeControls::addToRunTimeSelectionTable
addToRunTimeSelectionTable(runTimeCondition, averageCondition, dictionary)
Foam::functionObjects::runTimeControls::runTimeControl::read
virtual bool read(const dictionary &)
Read the runTimeControl data.
Definition: runTimeControl.C:86
Foam::functionObjects::runTimeControls::runTimeControl::write
virtual bool write()
Calculate the runTimeControl and write.
Definition: runTimeControl.C:322
Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:369
Foam::dictionary::set
entry * set(entry *entryPtr)
Assign a new entry, overwriting any existing entry.
Definition: dictionary.C:780
Foam::functionObjects::fvMeshFunctionObject
Specialization of Foam::functionObject for an Foam::fvMesh, providing a reference to the Foam::fvMesh...
Definition: fvMeshFunctionObject.H:64
runTimeControl
Controls when the calculation is terminated based on satisfying user-specified conditions.
forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: stdFoam.H:296
Foam::Time::writeAndEnd
bool writeAndEnd()
Write the objects now (not at end of iteration) and end the run.
Definition: TimeIO.C:603
Foam::blockMeshTools::read
void read(Istream &, label &val, const dictionary &)
In-place read with dictionary lookup.
Definition: blockMeshTools.C:57
runTimeCondition.H
Foam::check
static void check(const int retVal, const char *what)
Definition: ptscotchDecomp.C:80
Foam::Info
messageStream Info
Information stream (stdout output on master, null elsewhere)
Foam::List::setSize
void setSize(const label n)
Alias for resize()
Definition: List.H:222
Foam::dictionary::subDict
const dictionary & subDict(const word &keyword, enum keyType::option matchOpt=keyType::REGEX) const
Find and return a sub-dictionary.
Definition: dictionary.C:460
Foam::functionObjects::stateFunctionObject::setTrigger
bool setTrigger(const label triggeri, bool increaseOnly=true)
Set the trigger index. Normally only if greater than current.
Definition: stateFunctionObject.C:90
dict
dictionary dict
Definition: searchingEngine.H:14
Foam::FatalError
error FatalError
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
addToRunTimeSelectionTable.H
Macros for easy insertion into run-time selection tables.
fvMesh.H
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:144
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:130
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Global function forwards to reuseTmpDimensionedField::New.
Definition: DimensionedFieldReuseFunctions.H:105
Time.H
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:453
Foam::functionObject::name
const word & name() const noexcept
Return the name of this functionObject.
Definition: functionObject.C:143
Foam::nl
constexpr char nl
Definition: Ostream.H:404
Foam::functionObjects::timeFunctionObject::time
const Time & time() const
Return time database.
Definition: timeFunctionObject.H:96
Foam::functionObject::type
virtual const word & type() const =0
Runtime type information.
Foam::List< word >
Foam::Time::writeNow
bool writeNow()
Definition: TimeIO.C:596
Foam::functionObjects::runTimeControls::runTimeControl::satisfiedAction
satisfiedAction
Definition: runTimeControl.H:76
dictionary.H
Foam::labelMin
constexpr label labelMin
Definition: label.H:60
Foam::roots::type
type
Types of root.
Definition: Roots.H:54
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
Foam::functionObjects::runTimeControls::runTimeControl::execute
virtual bool execute()
Execute, currently does nothing.
Definition: runTimeControl.C:178
Foam::dictionary::toc
wordList toc() const
Return the table of contents.
Definition: dictionary.C:602
Foam::functionObjects::runTimeControls::runTimeCondition::groupID
virtual label groupID() const
Return the group index.
Definition: runTimeCondition.C:111
Foam::functionObjects::runTimeControls::runTimeCondition::active
virtual bool active() const
Return the active flag.
Definition: runTimeCondition.C:104
Foam::functionObjects::runTimeControls::runTimeControl::satisfiedAction::ABORT
"abort" - write and emit a FatalError
Foam::Time::run
virtual bool run() const
Return true if run should continue,.
Definition: Time.C:885
Foam::functionObjects::stateFunctionObject::setProperty
void setProperty(const word &entryName, const Type &value)
Add generic property.
Definition: stateFunctionObjectTemplates.C:59
Foam::functionObjects::runTimeControls::runTimeCondition::apply
virtual bool apply()=0
Apply the condition.