processorGAMGInterfaceField.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-2020 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 
28 #include "lduMatrix.H"
29 
30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
31 
32 namespace Foam
33 {
36  (
40  );
42  (
46  );
47 }
48 
49 
50 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
51 
53 (
54  const GAMGInterface& GAMGCp,
55  const lduInterfaceField& fineInterface
56 )
57 :
58  GAMGInterfaceField(GAMGCp, fineInterface),
59  procInterface_(refCast<const processorGAMGInterface>(GAMGCp)),
60  rank_(0)
61 {
63  refCast<const processorLduInterfaceField>(fineInterface);
64 
65  rank_ = p.rank();
66 }
67 
68 
70 (
71  const GAMGInterface& GAMGCp,
72  const int rank
73 )
74 :
75  GAMGInterfaceField(GAMGCp, rank),
76  procInterface_(refCast<const processorGAMGInterface>(GAMGCp)),
77  rank_(rank)
78 {}
79 
80 
81 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
82 
84 {}
85 
86 
87 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
88 
90 (
91  scalarField&,
92  const scalarField& psiInternal,
93  const scalarField&,
94  const direction,
95  const Pstream::commsTypes commsType
96 ) const
97 {
98  procInterface_.interfaceInternalField(psiInternal, scalarSendBuf_);
99 
100  if
101  (
104  )
105  {
106  // Fast path.
107  scalarReceiveBuf_.setSize(scalarSendBuf_.size());
108  outstandingRecvRequest_ = UPstream::nRequests();
110  (
112  procInterface_.neighbProcNo(),
113  reinterpret_cast<char*>(scalarReceiveBuf_.begin()),
114  scalarReceiveBuf_.byteSize(),
115  procInterface_.tag(),
116  comm()
117  );
118 
119  outstandingSendRequest_ = UPstream::nRequests();
121  (
123  procInterface_.neighbProcNo(),
124  reinterpret_cast<const char*>(scalarSendBuf_.begin()),
125  scalarSendBuf_.byteSize(),
126  procInterface_.tag(),
127  comm()
128  );
129  }
130  else
131  {
132  procInterface_.compressedSend(commsType, scalarSendBuf_);
133  }
134 
135  const_cast<processorGAMGInterfaceField&>(*this).updatedMatrix() = false;
136 }
137 
138 
140 (
141  scalarField& result,
142  const scalarField&,
143  const scalarField& coeffs,
144  const direction cmpt,
145  const Pstream::commsTypes commsType
146 ) const
147 {
148  if (updatedMatrix())
149  {
150  return;
151  }
152 
153  const labelUList& faceCells = procInterface_.faceCells();
154 
155  if
156  (
159  )
160  {
161  // Fast path.
162  if
163  (
164  outstandingRecvRequest_ >= 0
165  && outstandingRecvRequest_ < Pstream::nRequests()
166  )
167  {
168  UPstream::waitRequest(outstandingRecvRequest_);
169  }
170  // Recv finished so assume sending finished as well.
171  outstandingSendRequest_ = -1;
172  outstandingRecvRequest_ = -1;
173 
174  // Consume straight from scalarReceiveBuf_
175 
176  // Transform according to the transformation tensor
177  transformCoupleField(scalarReceiveBuf_, cmpt);
178 
179  // Multiply the field by coefficients and add into the result
180  forAll(faceCells, elemI)
181  {
182  result[faceCells[elemI]] -= coeffs[elemI]*scalarReceiveBuf_[elemI];
183  }
184  }
185  else
186  {
187  scalarField pnf
188  (
189  procInterface_.compressedReceive<scalar>(commsType, coeffs.size())
190  );
191  transformCoupleField(pnf, cmpt);
192 
193  forAll(faceCells, elemI)
194  {
195  result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
196  }
197  }
198 
199  const_cast<processorGAMGInterfaceField&>(*this).updatedMatrix() = true;
200 }
201 
202 
203 // ************************************************************************* //
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
Macros for easy insertion into run-time selection tables.
Abstract base class for GAMG agglomerated interface fields.
Abstract base class for GAMG agglomerated interfaces.
Definition: GAMGInterface.H:54
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:164
static label read(const commsTypes commsType, const int fromProcNo, char *buf, const std::streamsize bufSize, const int tag=UPstream::msgType(), const label communicator=0)
Read into given buffer from given processor and return the.
Definition: UIPread.C:79
static bool write(const commsTypes commsType, const int toProcNo, const char *buf, const std::streamsize bufSize, const int tag=UPstream::msgType(), const label communicator=0)
Write given buffer to given processor.
Definition: UOPwrite.C:34
commsTypes
Types of communications.
Definition: UPstream.H:65
static bool floatTransfer
Should compact transfer be used in which floats replace doubles.
Definition: UPstream.H:265
static label nRequests()
Get number of outstanding requests.
Definition: UPstream.C:137
static void waitRequest(const label i)
Wait until request i has finished.
Definition: UPstream.C:151
An abstract base class for implicitly-coupled interface fields e.g. processor and cyclic patch fields...
bool updatedMatrix() const
Whether matrix has been updated.
An abstract base class for implicitly-coupled interfaces e.g. processor and cyclic patches.
Definition: lduInterface.H:54
GAMG agglomerated processor interface field.
virtual void updateInterfaceMatrix(scalarField &result, const scalarField &psiInternal, const scalarField &coeffs, const direction cmpt, const Pstream::commsTypes commsType) const
Update result field based on interface functionality.
virtual void initInterfaceMatrixUpdate(scalarField &result, const scalarField &psiInternal, const scalarField &coeffs, const direction cmpt, const Pstream::commsTypes commsType) const
Initialise neighbour matrix update.
processorGAMGInterfaceField(const GAMGInterface &GAMGCp, const lduInterfaceField &fineInterface)
Construct from GAMG interface and fine level interface field.
GAMG agglomerated processor interface.
Abstract base class for processor coupled interfaces.
Namespace for OpenFOAM.
addToRunTimeSelectionTable(polyPatch, mergedCyclicPolyPatch, word)
To & refCast(From &r)
Reference type cast template function.
Definition: typeInfo.H:129
defineTypeNameAndDebug(combustionModel, 0)
uint8_t direction
Definition: direction.H:45
volScalarField & p