cyclicAMIPointPatchField.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 | Copyright (C) 2011-2016 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_(NULL),
43  nbrPpiPtr_(NULL)
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_(NULL),
58  nbrPpiPtr_(NULL)
59 {
60  if (!isType<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_(NULL),
84  nbrPpiPtr_(NULL)
85 {
86  if (!isType<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_(NULL),
108  nbrPpiPtr_(NULL)
109 {}
110 
111 
112 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
113 
114 template<class Type>
116 (
117  const Pstream::commsTypes,
118  Field<Type>& pField
119 ) const
120 {
121  if (cyclicAMIPatch_.cyclicAMIPatch().owner())
122  {
123  // We inplace modify pField. To prevent the other side (which gets
124  // evaluated at a later date) using already changed values we do
125  // all swaps on the side that gets evaluated first.
126 
127  // Get neighbouring pointPatch
128  const cyclicAMIPointPatch& nbrPatch = cyclicAMIPatch_.neighbPatch();
129 
130  // Get neighbouring pointPatchField
132  refCast<const GeometricField<Type, pointPatchField, pointMesh>>
133  (
134  this->internalField()
135  );
136 
137  const cyclicAMIPointPatchField<Type>& nbr =
138  refCast<const cyclicAMIPointPatchField<Type>>
139  (
140  fld.boundaryField()[nbrPatch.index()]
141  );
142 
143 
144  Field<Type> ptFld(this->patchInternalField(pField));
145  Field<Type> nbrPtFld(nbr.patchInternalField(pField));
146 
147 
148  if (doTransform())
149  {
150  const tensor& forwardT = this->forwardT()[0];
151  const tensor& reverseT = this->reverseT()[0];
152 
153  transform(ptFld, reverseT, ptFld);
154  transform(nbrPtFld, forwardT, nbrPtFld);
155  }
156 
157  // convert point field to face field, AMI interpolate, then
158  // face back to point
159  {
160  // add neighbour side contribution to owner
161  Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
162 
163  // interpolate to owner
164  if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
165  {
166  Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
167 
168  nbrFcFld =
169  cyclicAMIPatch_.cyclicAMIPatch().interpolate
170  (
171  nbrFcFld,
172  fcFld
173  );
174  }
175  else
176  {
177  nbrFcFld =
178  cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
179  }
180 
181  // add to internal field
182  this->addToInternalField
183  (
184  pField,
185  ppi().faceToPointInterpolate(nbrFcFld)()
186  );
187  }
188 
189  {
190  // add owner side contribution to neighbour
191  Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
192 
193  // interpolate to neighbour
194  if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
195  {
196  Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
197 
198  fcFld =
199  cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
200  (
201  fcFld,
202  nbrFcFld
203  );
204  }
205  else
206  {
207  fcFld =
208  cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
209  (
210  fcFld
211  );
212  }
213 
214  // add to internal field
215  nbr.addToInternalField
216  (
217  pField,
218  nbrPpi().faceToPointInterpolate(fcFld)()
219  );
220  }
221  }
222 }
223 
224 
225 // ************************************************************************* //
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:137
#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.
commsTypes
Types of communications.
Definition: UPstream.H:64
Foam::pointPatchFieldMapper.
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:253
Generic GeometricField class.
const cyclicAMIPointPatch & neighbPatch() const
Return neighbour point patch.
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.
const Boundary & boundaryField() const
Return const-reference to the boundary field.
Pre-declare SubField and related Field type.
Definition: Field.H:57
#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.
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.
dimensionSet transform(const dimensionSet &)
Definition: dimensionSet.C:465
IOerror FatalIOError