cyclicAMIPointPatchField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 \*---------------------------------------------------------------------------*/
25 
27 #include "Swap.H"
28 #include "transformField.H"
29 #include "pointFields.H"
30 
31 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
32 
33 template<class Type>
35 (
36  const pointPatch& p,
38 )
39 :
41  cyclicAMIPatch_(refCast<const cyclicAMIPointPatch>(p)),
42  ppiPtr_(nullptr),
43  nbrPpiPtr_(nullptr)
44 {}
45 
46 
47 template<class Type>
49 (
50  const pointPatch& p,
52  const dictionary& dict
53 )
54 :
56  cyclicAMIPatch_(refCast<const cyclicAMIPointPatch>(p)),
57  ppiPtr_(nullptr),
58  nbrPpiPtr_(nullptr)
59 {
60  if (!isA<cyclicAMIPointPatch>(p))
61  {
63  (
64  dict
65  ) << "patch " << this->patch().index() << " not cyclicAMI type. "
66  << "Patch type = " << p.type()
67  << exit(FatalIOError);
68  }
69 }
70 
71 
72 template<class Type>
74 (
76  const pointPatch& p,
78  const pointPatchFieldMapper& mapper
79 )
80 :
81  coupledPointPatchField<Type>(ptf, p, iF, mapper),
82  cyclicAMIPatch_(refCast<const cyclicAMIPointPatch>(p)),
83  ppiPtr_(nullptr),
84  nbrPpiPtr_(nullptr)
85 {
86  if (!isA<cyclicAMIPointPatch>(this->patch()))
87  {
89  << "Field type does not correspond to patch type for patch "
90  << this->patch().index() << "." << endl
91  << "Field type: " << typeName << endl
92  << "Patch type: " << this->patch().type()
93  << exit(FatalError);
94  }
95 }
96 
97 
98 template<class Type>
100 (
103 )
104 :
106  cyclicAMIPatch_(ptf.cyclicAMIPatch_),
107  ppiPtr_(nullptr),
108  nbrPpiPtr_(nullptr)
109 {}
110 
111 
112 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
113 
114 template<class Type>
116 {
117  return cyclicAMIPatch_.coupled();
118 }
119 
120 
121 template<class Type>
123 (
124  const Pstream::commsTypes,
125  Field<Type>& pField
126 ) const
127 {
128  if (cyclicAMIPatch_.cyclicAMIPatch().owner())
129  {
130  // We inplace modify pField. To prevent the other side (which gets
131  // evaluated at a later date) using already changed values we do
132  // all swaps on the side that gets evaluated first.
133 
134  // Get neighbouring pointPatch
135  const cyclicAMIPointPatch& nbrPatch = cyclicAMIPatch_.neighbPatch();
136 
137  // Get neighbouring pointPatchField
139  refCast<const GeometricField<Type, pointPatchField, pointMesh>>
140  (
141  this->internalField()
142  );
143 
144  const cyclicAMIPointPatchField<Type>& nbr =
145  refCast<const cyclicAMIPointPatchField<Type>>
146  (
147  fld.boundaryField()[nbrPatch.index()]
148  );
149 
150 
151  Field<Type> ptFld(this->patchInternalField(pField));
152  Field<Type> nbrPtFld(nbr.patchInternalField(pField));
153 
154 
155  if (doTransform())
156  {
157  const tensor& forwardT = this->forwardT()[0];
158  const tensor& reverseT = this->reverseT()[0];
159 
160  transform(ptFld, reverseT, ptFld);
161  transform(nbrPtFld, forwardT, nbrPtFld);
162  }
163 
164  // convert point field to face field, AMI interpolate, then
165  // face back to point
166  {
167  // add neighbour side contribution to owner
168  Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
169 
170  // interpolate to owner
171  if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
172  {
173  Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
174 
175  nbrFcFld =
176  cyclicAMIPatch_.cyclicAMIPatch().interpolate
177  (
178  nbrFcFld,
179  fcFld
180  );
181  }
182  else
183  {
184  nbrFcFld =
185  cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
186  }
187 
188  // add to internal field
189  this->addToInternalField
190  (
191  pField,
192  ppi().faceToPointInterpolate(nbrFcFld)()
193  );
194  }
195 
196  {
197  // add owner side contribution to neighbour
198  Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
199 
200  // interpolate to neighbour
201  if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
202  {
203  Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
204 
205  fcFld =
206  cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
207  (
208  fcFld,
209  nbrFcFld
210  );
211  }
212  else
213  {
214  fcFld =
215  cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
216  (
217  fcFld
218  );
219  }
220 
221  // add to internal field
222  nbr.addToInternalField
223  (
224  pField,
225  nbrPpi().faceToPointInterpolate(fcFld)()
226  );
227  }
228  }
229 }
230 
231 
232 // ************************************************************************* //
dictionary dict
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
error FatalError
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:158
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
cyclicAMIPointPatchField(const pointPatch &, const DimensionedField< Type, pointMesh > &)
Construct from patch and internal field.
const Boundary & boundaryField() const
Return const-reference to the boundary field.
commsTypes
Types of communications.
Definition: UPstream.H:64
Foam::pointPatchFieldMapper.
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:256
virtual bool coupled() const
Return true if coupled. Note that the underlying patch.
Generic GeometricField class.
virtual label index() const
Return the index of this patch in the pointBoundaryMesh.
virtual void swapAddSeparated(const Pstream::commsTypes commsType, Field< Type > &) const
Complete swap of patch point values and add to local values.
Spatial transformation functions for primitive fields.
gmvFile<< "tracers "<< particles.size()<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().x()<< ' ';}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().y()<< ' ';}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().z()<< ' ';}gmvFile<< nl;forAll(lagrangianScalarNames, i){ const word &name=lagrangianScalarNames[i];IOField< scalar > fld(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
Cyclic AMI front and back plane patch field.
Pre-declare SubField and related Field type.
Definition: Field.H:56
const cyclicAMIPointPatch & neighbPatch() const
Return neighbour point patch.
#define FatalIOErrorInFunction(ios)
Report an error message using Foam::FatalIOError.
Definition: error.H:331
Basic pointPatch represents a set of points from the mesh.
Definition: pointPatch.H:56
A Coupled boundary condition for pointField.
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Swap its arguments.
volScalarField & p
Cyclic AMI point patch - place holder only.
dimensionSet transform(const dimensionSet &)
Definition: dimensionSet.C:477
IOerror FatalIOError