coupledFaPatchField.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) 2016-2017 Wikki Ltd
9 -------------------------------------------------------------------------------
10 License
11  This file is part of OpenFOAM.
12 
13  OpenFOAM is free software: you can redistribute it and/or modify it
14  under the terms of the GNU General Public License as published by
15  the Free Software Foundation, either version 3 of the License, or
16  (at your option) any later version.
17 
18  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21  for more details.
22 
23  You should have received a copy of the GNU General Public License
24  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25 
26 \*---------------------------------------------------------------------------*/
27 
28 #include "coupledFaPatchField.H"
29 
30 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
31 
32 template<class Type>
34 (
35  const faPatch& p,
37 )
38 :
39  lduInterfaceField(refCast<const lduInterface>(p)),
41 {}
42 
43 
44 template<class Type>
46 (
47  const faPatch& p,
49  const Field<Type>& f
50 )
51 :
52  lduInterfaceField(refCast<const lduInterface>(p)),
53  faPatchField<Type>(p, iF, f)
54 {}
55 
56 
57 template<class Type>
59 (
60  const coupledFaPatchField<Type>& ptf,
61  const faPatch& p,
63  const faPatchFieldMapper& mapper
64 )
65 :
66  lduInterfaceField(refCast<const lduInterface>(p)),
67  faPatchField<Type>(ptf, p, iF, mapper)
68 {}
69 
70 
71 template<class Type>
73 (
74  const faPatch& p,
76  const dictionary& dict
77 )
78 :
79  lduInterfaceField(refCast<const lduInterface>(p, dict)),
81 {}
82 
83 
84 template<class Type>
86 (
87  const coupledFaPatchField<Type>& ptf
88 )
89 :
90  lduInterfaceField(refCast<const lduInterface>(ptf.patch())),
92 {}
93 
94 
95 template<class Type>
97 (
98  const coupledFaPatchField<Type>& ptf,
100 )
101 :
102  lduInterfaceField(refCast<const lduInterface>(ptf.patch())),
103  faPatchField<Type>(ptf, iF)
104 {}
105 
106 
107 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
108 
109 template<class Type>
111 {
112  return
113  (patchNeighbourField() - this->patchInternalField())
114  *this->patch().deltaCoeffs();
115 }
116 
117 
118 template<class Type>
120 {
121  if (!this->updated())
122  {
123  this->updateCoeffs();
124  }
125 }
126 
127 
128 template<class Type>
130 {
132  (
133  this->patch().weights()*this->patchInternalField()
134  + (1.0 - this->patch().weights())*patchNeighbourField()
135  );
136 }
137 
138 
139 template<class Type>
142 (
143  const tmp<scalarField>& w
144 ) const
145 {
146  return Type(pTraits<Type>::one)*w;
147 }
148 
149 
150 template<class Type>
153 (
154  const tmp<scalarField>& w
155 ) const
156 {
157  return Type(pTraits<Type>::one)*(1.0 - w);
158 }
159 
160 
161 template<class Type>
164 {
165  return -Type(pTraits<Type>::one)*this->patch().deltaCoeffs();
166 }
167 
168 
169 template<class Type>
172 {
173  return -gradientInternalCoeffs();
174 }
175 
176 
177 template<class Type>
179 {
181  this->writeEntry("value", os);
182 }
183 
184 
185 // ************************************************************************* //
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::tmp
A class for managing temporary objects.
Definition: PtrList.H:61
Foam::coupledFaPatchField::initEvaluate
virtual void initEvaluate(const Pstream::commsTypes commsType)
Initialise the evaluation of the patch field.
Definition: coupledFaPatchField.C:119
Foam::coupledFaPatchField::coupledFaPatchField
coupledFaPatchField(const faPatch &, const DimensionedField< Type, areaMesh > &)
Construct from patch and internal field.
Definition: coupledFaPatchField.C:34
Foam::faPatchFieldMapper
Definition: faPatchFieldMapper.H:44
Foam::coupledFaPatchField::gradientBoundaryCoeffs
virtual tmp< Field< Type > > gradientBoundaryCoeffs() const
Return the matrix source coefficients corresponding to the.
Definition: coupledFaPatchField.C:171
Foam::coupledFaPatchField::gradientInternalCoeffs
virtual tmp< Field< Type > > gradientInternalCoeffs() const
Return the matrix diagonal coefficients corresponding to the.
Definition: coupledFaPatchField.C:163
Foam::Field
Generic templated field type.
Definition: Field.H:63
Foam::coupledFaPatchField::evaluate
virtual void evaluate(const Pstream::commsTypes commsType)
Evaluate the patch field.
Definition: coupledFaPatchField.C:129
coupledFaPatchField.H
dict
dictionary dict
Definition: searchingEngine.H:14
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
os
OBJstream os(runTime.globalPath()/outputName)
Foam::coupledFaPatchField::valueBoundaryCoeffs
virtual tmp< Field< Type > > valueBoundaryCoeffs(const tmp< scalarField > &) const
Return the matrix source coefficients corresponding to the.
Definition: coupledFaPatchField.C:153
Foam::lduInterfaceField
An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields...
Definition: lduInterfaceField.H:58
Foam::coupledFaPatchField::snGrad
virtual tmp< Field< Type > > snGrad() const
Return patch-normal gradient.
Definition: coupledFaPatchField.C:110
Foam::UPstream::commsTypes
commsTypes
Types of communications.
Definition: UPstream.H:69
Foam::coupledFaPatchField
Author Zeljko Tukovic, FMENA Hrvoje Jasak, Wikki Ltd.
Definition: coupledFaPatchField.H:57
f
labelList f(nPoints)
Foam::foamVersion::patch
const std::string patch
OpenFOAM patch number as a std::string.
Foam::pTraits
A traits class, which is primarily used for primitives.
Definition: pTraits.H:56
Foam::vtk::write
void write(vtk::formatter &fmt, const Type &val, const label n=1)
Component-wise write of a value (N times)
Definition: foamVtkOutputTemplates.C:36
Foam::coupledFaPatchField::valueInternalCoeffs
virtual tmp< Field< Type > > valueInternalCoeffs(const tmp< scalarField > &) const
Return the matrix diagonal coefficients corresponding to the.
Definition: coupledFaPatchField.C:142
Foam::coupledFaPatchField::write
virtual void write(Ostream &) const
Write.
Definition: coupledFaPatchField.C:178
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::faPatchField::patch
const faPatch & patch() const
Return patch.
Definition: faPatchField.H:279
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:54