lduMatrixSmoother.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 "lduMatrix.H"
30 
31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
32 
33 namespace Foam
34 {
35  defineRunTimeSelectionTable(lduMatrix::smoother, symMatrix);
36  defineRunTimeSelectionTable(lduMatrix::smoother, asymMatrix);
37 }
38 
39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
40 
43 (
44  const dictionary& solverControls
45 )
46 {
47  word name;
48 
49  // Handle primitive or dictionary entry
50  const entry& e =
51  solverControls.lookupEntry("smoother", keyType::LITERAL);
52 
53  if (e.isDict())
54  {
55  e.dict().readEntry("smoother", name);
56  }
57  else
58  {
59  e.stream() >> name;
60  }
61 
62  return name;
63 }
64 
65 
67 (
68  const word& fieldName,
69  const lduMatrix& matrix,
70  const FieldField<Field, scalar>& interfaceBouCoeffs,
71  const FieldField<Field, scalar>& interfaceIntCoeffs,
72  const lduInterfaceFieldPtrsList& interfaces,
73  const dictionary& solverControls
74 )
75 {
76  word name;
77 
78  // Handle primitive or dictionary entry
79  const entry& e =
80  solverControls.lookupEntry("smoother", keyType::LITERAL);
81 
82  if (e.isDict())
83  {
84  e.dict().readEntry("smoother", name);
85  }
86  else
87  {
88  e.stream() >> name;
89  }
90 
91  // not (yet?) needed:
92  // const dictionary& controls = e.isDict() ? e.dict() : dictionary::null;
93 
94  if (matrix.symmetric())
95  {
96  auto* ctorPtr = symMatrixConstructorTable(name);
97 
98  if (!ctorPtr)
99  {
101  (
102  solverControls,
103  "symmetric matrix smoother",
104  name,
105  *symMatrixConstructorTablePtr_
106  ) << exit(FatalIOError);
107  }
108 
110  (
111  ctorPtr
112  (
113  fieldName,
114  matrix,
115  interfaceBouCoeffs,
116  interfaceIntCoeffs,
117  interfaces
118  )
119  );
120  }
121  else if (matrix.asymmetric())
122  {
123  auto* ctorPtr = asymMatrixConstructorTable(name);
124 
125  if (!ctorPtr)
126  {
128  (
129  solverControls,
130  "asymmetric matrix smoother",
131  name,
132  *asymMatrixConstructorTablePtr_
133  ) << exit(FatalIOError);
134  }
135 
137  (
138  ctorPtr
139  (
140  fieldName,
141  matrix,
142  interfaceBouCoeffs,
143  interfaceIntCoeffs,
144  interfaces
145  )
146  );
147  }
148 
149  FatalIOErrorInFunction(solverControls)
150  << "cannot solve incomplete matrix, "
151  "no diagonal or off-diagonal coefficient"
152  << exit(FatalIOError);
153 
154  return nullptr;
155 }
156 
157 
158 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
159 
161 (
162  const word& fieldName,
163  const lduMatrix& matrix,
164  const FieldField<Field, scalar>& interfaceBouCoeffs,
165  const FieldField<Field, scalar>& interfaceIntCoeffs,
166  const lduInterfaceFieldPtrsList& interfaces
167 )
168 :
169  fieldName_(fieldName),
170  matrix_(matrix),
171  interfaceBouCoeffs_(interfaceBouCoeffs),
172  interfaceIntCoeffs_(interfaceIntCoeffs),
173  interfaces_(interfaces)
174 {}
175 
176 
177 // ************************************************************************* //
Foam::entry
A keyword and a list of tokens is an 'entry'.
Definition: entry.H:67
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:65
Foam::FieldField
A field of fields is a PtrList of fields with reference counting.
Definition: FieldField.H:53
Foam::defineRunTimeSelectionTable
defineRunTimeSelectionTable(reactionRateFlameArea, dictionary)
Foam::lduMatrix
lduMatrix is a general matrix class in which the coefficients are stored as three arrays,...
Definition: lduMatrix.H:83
Foam::lduMatrix::symmetric
bool symmetric() const
Definition: lduMatrix.H:628
Foam::FatalIOError
IOerror FatalIOError
lduMatrix.H
Foam::dictionary::lookupEntry
const entry & lookupEntry(const word &keyword, enum keyType::option matchOpt) const
Search for an entry (const access) with the given keyword.
Definition: dictionary.C:366
FatalIOErrorInLookup
#define FatalIOErrorInLookup(ios, lookupTag, lookupName, lookupTable)
Report an error message using Foam::FatalIOError.
Definition: error.H:478
Foam::UPtrList< const lduInterfaceField >
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
Foam::lduMatrix::smoother::getName
static word getName(const dictionary &)
Find the smoother name (directly or from a sub-dictionary)
Definition: lduMatrixSmoother.C:43
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::lduMatrix::smoother::New
static autoPtr< smoother > New(const word &fieldName, const lduMatrix &matrix, const FieldField< Field, scalar > &interfaceBouCoeffs, const FieldField< Field, scalar > &interfaceIntCoeffs, const lduInterfaceFieldPtrsList &interfaces, const dictionary &solverControls)
Return a new smoother.
Definition: lduMatrixSmoother.C:67
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:130
Foam::autoPtr
Pointer management similar to std::unique_ptr, with some additional methods and type checking.
Definition: HashPtrTable.H:53
Foam::lduMatrix::smoother::smoother
smoother(const word &fieldName, const lduMatrix &matrix, const FieldField< Field, scalar > &interfaceBouCoeffs, const FieldField< Field, scalar > &interfaceIntCoeffs, const lduInterfaceFieldPtrsList &interfaces)
Definition: lduMatrixSmoother.C:161
Foam::constant::electromagnetic::e
const dimensionedScalar e
Elementary charge.
Definition: createFields.H:11
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
Foam::lduMatrix::asymmetric
bool asymmetric() const
Definition: lduMatrix.H:633
FatalIOErrorInFunction
#define FatalIOErrorInFunction(ios)
Report an error message using Foam::FatalIOError.
Definition: error.H:473