genericFaPatchField.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) 2011-2016 OpenFOAM Foundation
9  Copyright (C) 2019-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 "genericFaPatchField.H"
30 #include "faPatchFieldMapper.H"
31 
32 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
33 
34 template<class Type>
36 (
37  const faPatch& p,
39 )
40 :
41  parent_bctype(p, iF)
42 {
44  << "Trying to construct genericFaPatchField on patch "
45  << this->patch().name()
46  << " of field " << this->internalField().name() << nl
47  << abort(FatalError);
48 }
49 
50 
51 template<class Type>
53 (
54  const faPatch& p,
56  const dictionary& dict
57 )
58 :
59  parent_bctype(p, iF, dict),
61 {
62  const label patchSize = this->size();
63  const word& patchName = this->patch().name();
64  const IOobject& io = this->internalField();
65 
66  if (!dict.found("value"))
67  {
68  reportMissingEntry("value", patchName, io);
69  }
70 
71  // Handle "value" separately
72  processGeneric(patchSize, patchName, io, true);
73 }
74 
75 
76 template<class Type>
78 (
79  const genericFaPatchField<Type>& rhs,
80  const faPatch& p,
82  const faPatchFieldMapper& mapper
83 )
84 :
85  parent_bctype(rhs, p, iF, mapper),
87 {
88  this->mapGeneric(rhs, mapper);
89 }
90 
91 
92 template<class Type>
94 (
95  const genericFaPatchField<Type>& rhs,
97 )
98 :
99  parent_bctype(rhs, iF),
101 {}
102 
103 
104 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
105 
106 template<class Type>
108 {
109  // Handle "value" separately
110  genericPatchFieldBase::writeGeneric(os, true);
111  this->writeEntry("value", os);
112 }
113 
114 
115 template<class Type>
117 (
118  const faPatchFieldMapper& m
119 )
120 {
121  parent_bctype::autoMap(m);
122  this->autoMapGeneric(m);
123 }
124 
125 
126 template<class Type>
128 (
129  const faPatchField<Type>& rhs,
130  const labelList& addr
131 )
132 {
133  parent_bctype::rmap(rhs, addr);
134 
135  const auto* base = isA<genericPatchFieldBase>(rhs);
136  if (base)
137  {
138  this->rmapGeneric(*base, addr);
139  }
140 }
141 
142 
143 template<class Type>
146 (
147  const tmp<scalarField>&
148 ) const
149 {
151  << "Cannot be called for a genericFaPatchField";
152 
153  genericFatalSolveError
154  (
155  this->patch().name(),
156  this->internalField()
157  );
159 
160  return *this;
161 }
162 
163 
164 template<class Type>
167 (
168  const tmp<scalarField>&
169 ) const
170 {
172  << "Cannot be called for a genericFaPatchField";
173 
174  genericFatalSolveError
175  (
176  this->patch().name(),
177  this->internalField()
178  );
180 
181  return *this;
182 }
183 
184 
185 template<class Type>
188 {
190  << "Cannot be called for a genericFaPatchField";
191 
192  genericFatalSolveError
193  (
194  this->patch().name(),
195  this->internalField()
196  );
198 
199  return *this;
200 }
201 
202 
203 template<class Type>
206 {
208  << "Cannot be called for a genericFaPatchField";
209 
210  genericFatalSolveError
211  (
212  this->patch().name(),
213  this->internalField()
214  );
216 
217  return *this;
218 }
219 
220 
221 // ************************************************************************* //
Foam::genericFaPatchField::gradientInternalCoeffs
tmp< Field< Type > > gradientInternalCoeffs() const
Fatal.
Definition: genericFaPatchField.C:187
Foam::IOobject
Defines the attributes of an object for which implicit objectRegistry management is supported,...
Definition: IOobject.H:169
p
volScalarField & p
Definition: createFieldRefs.H:8
Foam::faPatchField
faPatchField<Type> abstract base class. This class gives a fat-interface to all derived classes cover...
Definition: areaFieldsFwd.H:50
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:65
Foam::genericPatchFieldBase
Generic infrastructure for reading/writing unknown patch types.
Definition: genericPatchFieldBase.H:54
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:61
Foam::faPatchFieldMapper
Definition: faPatchFieldMapper.H:44
faPatchFieldMapper.H
genericFaPatchField.H
Foam::calculatedFaPatchField
Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd.
Definition: calculatedFaPatchField.H:54
Foam::genericFaPatchField
This boundary condition provides a generic version of the calculated condition, useful as a fallback ...
Definition: genericFaPatchField.H:58
Foam::genericFaPatchField::write
virtual void write(Ostream &) const
Write.
Definition: genericFaPatchField.C:107
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
Foam::genericFaPatchField::rmap
virtual void rmap(const faPatchField< Type > &, const labelList &)
Reverse map the given faPatchField onto this faPatchField.
Definition: genericFaPatchField.C:128
os
OBJstream os(runTime.globalPath()/outputName)
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:144
Foam::genericFaPatchField::valueInternalCoeffs
virtual tmp< Field< Type > > valueInternalCoeffs(const tmp< scalarField > &) const
Fatal.
Definition: genericFaPatchField.C:146
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:453
Foam::nl
constexpr char nl
Definition: Ostream.H:404
Foam::foamVersion::patch
const std::string patch
OpenFOAM patch number as a std::string.
Foam::genericFaPatchField::gradientBoundaryCoeffs
tmp< Field< Type > > gradientBoundaryCoeffs() const
Fatal.
Definition: genericFaPatchField.C:205
Foam::List< label >
Foam::genericFaPatchField::autoMap
virtual void autoMap(const faPatchFieldMapper &)
Map (and resize as needed) from self given a mapping object.
Definition: genericFaPatchField.C:117
Foam::genericFaPatchField::valueBoundaryCoeffs
virtual tmp< Field< Type > > valueBoundaryCoeffs(const tmp< scalarField > &) const
Fatal.
Definition: genericFaPatchField.C:167
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
Foam::Ostream
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:56
Foam::faPatch
Finite area patch class. Used for 2-D non-Euclidian finite area method.
Definition: faPatch.H:69
Foam::genericFaPatchField::genericFaPatchField
genericFaPatchField(const faPatch &, const DimensionedField< Type, areaMesh > &)
Construct from patch and internal field.
Definition: genericFaPatchField.C:36
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:54
Foam::zero
A class representing the concept of 0 (zero) that can be used to avoid manipulating objects known to ...
Definition: zero.H:62