FreeFOAM The Cross-Platform CFD Toolkit
fieldAverageTemplates.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) 1991-2010 OpenCFD Ltd.
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 <finiteVolume/volFields.H>
28 #include <OpenFOAM/OFstream.H>
29 
30 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
31 
32 template<class Type>
34 (
35  const label fieldI,
36  wordList& meanFieldList
37 ) const
38 {
39  if (faItems_[fieldI].mean())
40  {
42 
43  const word& fieldName = faItems_[fieldI].fieldName();
44 
45  const word meanFieldName = fieldName + EXT_MEAN;
46 
47  Info<< "Reading/calculating field " << meanFieldName << nl << endl;
48 
49  if (obr_.foundObject<fieldType>(meanFieldName))
50  {
51  meanFieldList[fieldI] = meanFieldName;
52  }
53  else if (obr_.found(meanFieldName))
54  {
55  Info<< "Cannot allocate average field " << meanFieldName
56  << " since an object with that name already exists."
57  << " Disabling averaging." << nl << endl;
58  meanFieldList[fieldI] = word::null;
59  }
60  else
61  {
62  const fieldType& baseField =
63  obr_.lookupObject<fieldType>(fieldName);
64 
65  // Store on registry
66  obr_.store
67  (
68  new fieldType
69  (
70  IOobject
71  (
72  meanFieldName,
73  obr_.time().timeName(),
74  obr_,
75  IOobject::READ_IF_PRESENT,
76  IOobject::NO_WRITE
77  ),
78  1*baseField
79  )
80  );
81 
82  meanFieldList[fieldI] = meanFieldName;
83  }
84  }
85 }
86 
87 
88 template<class Type1, class Type2>
90 (
91  const label fieldI,
92  const wordList& meanFieldList,
93  wordList& prime2MeanFieldList
94 ) const
95 {
96  if (faItems_[fieldI].mean() && meanFieldList[fieldI].size())
97  {
100 
101  const word& fieldName = faItems_[fieldI].fieldName();
102 
103  const word meanFieldName = fieldName + EXT_PRIME2MEAN;
104  Info<< "Reading/calculating field " << meanFieldName << nl << endl;
105 
106  if (obr_.foundObject<fieldType2>(meanFieldName))
107  {
108  prime2MeanFieldList[fieldI] = meanFieldName;
109  }
110  else if (obr_.found(meanFieldName))
111  {
112  Info<< "Cannot allocate average field " << meanFieldName
113  << " since an object with that name already exists."
114  << " Disabling averaging." << nl << endl;
115  prime2MeanFieldList[fieldI] = word::null;
116  }
117  else
118  {
119  const fieldType1& baseField =
120  obr_.lookupObject<fieldType1>(fieldName);
121  const fieldType1& meanField =
122  obr_.lookupObject<fieldType1>(meanFieldList[fieldI]);
123 
124  obr_.store
125  (
126  new fieldType2
127  (
128  IOobject
129  (
130  meanFieldName,
131  obr_.time().timeName(),
132  obr_,
133  IOobject::READ_IF_PRESENT,
134  IOobject::NO_WRITE
135  ),
136  sqr(baseField) - sqr(meanField)
137  )
138  );
139 
140  prime2MeanFieldList[fieldI] = meanFieldName;
141  }
142  }
143 }
144 
145 
146 template<class Type>
148 const
149 {
151 
152  const scalar dt = obr_.time().deltaT().value();
153 
154  forAll(faItems_, i)
155  {
156  if (faItems_[i].mean() && meanFieldList[i].size())
157  {
158  const word& fieldName = faItems_[i].fieldName();
159  const fieldType& baseField =
160  obr_.lookupObject<fieldType>(fieldName);
161  fieldType& meanField = const_cast<fieldType&>
162  (
163  obr_.lookupObject<fieldType>(meanFieldList[i])
164  );
165 
166  scalar alpha = 0.0;
167  scalar beta = 0.0;
168  if (faItems_[i].timeBase())
169  {
170  alpha = (totalTime_[i] - dt)/totalTime_[i];
171  beta = dt/totalTime_[i];
172  }
173  else
174  {
175  alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
176  beta = 1.0/scalar(totalIter_[i]);
177  }
178 
179  meanField = alpha*meanField + beta*baseField;
180  }
181  }
182 }
183 
184 
185 template<class Type1, class Type2>
187 (
188  const wordList& meanFieldList,
189  const wordList& prime2MeanFieldList
190 ) const
191 {
194 
195  const scalar dt = obr_.time().deltaT().value();
196 
197  forAll(faItems_, i)
198  {
199  if
200  (
201  faItems_[i].prime2Mean()
202  && meanFieldList[i].size()
203  && prime2MeanFieldList[i].size()
204  )
205  {
206  const word& fieldName = faItems_[i].fieldName();
207  const fieldType1& baseField =
208  obr_.lookupObject<fieldType1>(fieldName);
209  const fieldType1& meanField =
210  obr_.lookupObject<fieldType1>(meanFieldList[i]);
211  fieldType2& prime2MeanField = const_cast<fieldType2&>
212  (
213  obr_.lookupObject<fieldType2>(prime2MeanFieldList[i])
214  );
215 
216  scalar alpha = 0.0;
217  scalar beta = 0.0;
218  if (faItems_[i].timeBase())
219  {
220  alpha = (totalTime_[i] - dt)/totalTime_[i];
221  beta = dt/totalTime_[i];
222  }
223  else
224  {
225  alpha = scalar(totalIter_[i] - 1)/scalar(totalIter_[i]);
226  beta = 1.0/scalar(totalIter_[i]);
227  }
228 
229  prime2MeanField =
230  alpha*prime2MeanField
231  + beta*sqr(baseField)
232  - sqr(meanField);
233  }
234  }
235 }
236 
237 
238 template<class Type1, class Type2>
240 (
241  const wordList& meanFieldList,
242  const wordList& prime2MeanFieldList
243 ) const
244 {
247 
248  forAll(faItems_, i)
249  {
250  if
251  (
252  faItems_[i].prime2Mean()
253  && meanFieldList[i].size()
254  && prime2MeanFieldList[i].size()
255  )
256  {
257  const fieldType1& meanField =
258  obr_.lookupObject<fieldType1>(meanFieldList[i]);
259  fieldType2& prime2MeanField = const_cast<fieldType2&>
260  (
261  obr_.lookupObject<fieldType2>(prime2MeanFieldList[i])
262  );
263 
264  prime2MeanField += sqr(meanField);
265  }
266  }
267 }
268 
269 
270 template<class Type>
271 void Foam::fieldAverage::writeFieldList(const wordList& fieldList) const
272 {
274 
275  forAll(fieldList, i)
276  {
277  if (fieldList[i].size())
278  {
279  const fieldType& f = obr_.lookupObject<fieldType>(fieldList[i]);
280  f.write();
281  }
282  }
283 }
284 
285 
286 // ************************ vim: set sw=4 sts=4 et: ************************ //