FieldI.H
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) 2018-2021 OpenCFD Ltd.
9 -------------------------------------------------------------------------------
10 License
11  This file is part of OpenFOAM.
12 
13  OpenFOAM is free software: you can redistribute it and/or modify it
14  under the terms of the GNU General Public License as published by
15  the Free Software Foundation, either version 3 of the License, or
16  (at your option) any later version.
17 
18  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21  for more details.
22 
23  You should have received a copy of the GNU General Public License
24  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25 
26 \*---------------------------------------------------------------------------*/
27 
28 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
29 
30 template<class Type>
32 {
33  return NullObjectRef<Field<Type>>();
34 }
35 
36 
37 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
38 
39 template<class Type>
40 inline constexpr Foam::Field<Type>::Field() noexcept
41 :
42  List<Type>()
43 {}
44 
45 
46 template<class Type>
47 inline Foam::Field<Type>::Field(const label len)
48 :
49  List<Type>(len)
50 {}
51 
52 
53 template<class Type>
54 inline Foam::Field<Type>::Field(const label len, const Type& val)
55 :
56  List<Type>(len, val)
57 {}
58 
59 
60 template<class Type>
61 inline Foam::Field<Type>::Field(const label len, const Foam::zero)
62 :
63  List<Type>(len, Zero)
64 {}
65 
66 
67 template<class Type>
68 inline Foam::Field<Type>::Field(const Foam::one, const Type& val)
69 :
70  List<Type>(Foam::one{}, val)
71 {}
72 
73 
74 template<class Type>
75 inline Foam::Field<Type>::Field(const Foam::one, Type&& val)
76 :
77  List<Type>(Foam::one{}, std::move(val))
78 {}
79 
80 
81 template<class Type>
83 :
84  List<Type>(Foam::one{}, Zero)
85 {}
86 
87 
88 template<class Type>
90 :
91  List<Type>(fld)
92 {}
93 
94 
95 template<class Type>
97 :
98  List<Type>(list)
99 {}
100 
101 
102 template<class Type>
103 template<class Addr>
105 :
106  List<Type>(list)
107 {}
108 
109 
110 template<class Type>
112 :
113  List<Type>()
114 {
116 }
117 
118 
119 template<class Type>
121 :
122  List<Type>()
123 {
124  List<Type>::transfer(list);
125 }
126 
127 
128 template<class Type>
129 template<int SizeMin>
131 :
132  List<Type>()
133 {
134  List<Type>::transfer(list);
135 }
136 
137 
138 template<class Type>
140 :
141  List<Type>(fld, reuse)
142 {}
143 
144 
145 template<class Type>
147 :
148  List<Type>(tfld.constCast(), tfld.movable())
149 {
150  tfld.clear();
151 }
152 
153 
154 template<class Type>
156 :
157  List<Type>(is)
158 {}
159 
160 
161 template<class Type>
163 {
164  return tmp<Field<Type>>::New(*this);
165 }
166 
167 
168 // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
169 
170 template<class Type>
172 {
174 }
175 
176 
177 template<class Type>
179 {
181 }
182 
183 
184 template<class Type>
185 template<class Addr>
186 inline void Foam::Field<Type>::operator=
187 (
189 )
190 {
192 }
193 
194 
195 template<class Type>
197 {
199 }
200 
201 
202 template<class Type>
204 {
206 }
207 
208 
209 template<class Type>
210 template<int SizeMin>
212 {
214 }
215 
216 
217 template<class Type>
218 inline void Foam::Field<Type>::operator=(const Type& val)
219 {
221 }
222 
223 
224 template<class Type>
226 {
228 }
229 
230 
231 // ************************************************************************* //
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:61
Foam::Zero
static constexpr const zero Zero
Global zero (0)
Definition: zero.H:131
Foam::DynamicList
A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects.
Definition: DynamicList.H:55
Foam::one
A class representing the concept of 1 (one) that can be used to avoid manipulating objects known to b...
Definition: one.H:61
Foam::Field::clone
tmp< Field< Type > > clone() const
Clone.
Definition: FieldI.H:162
Foam::Field::Field
constexpr Field() noexcept
Default construct.
Definition: FieldI.H:40
Foam::SubField
SubField is a Field obtained as a section of another Field, without its own allocation....
Definition: Field.H:64
Foam::Field
Generic templated field type.
Definition: Field.H:63
Foam::Istream
An Istream is an abstract base class for all input systems (streams, files, token lists etc)....
Definition: Istream.H:61
fld
gmvFile<< "tracers "<< particles.size()<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().x()<< ' ';}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().y()<< ' ';}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().z()<< ' ';}gmvFile<< nl;for(const word &name :lagrangianScalarNames){ IOField< scalar > fld(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
Definition: gmvOutputLagrangian.H:23
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::Field::operator=
void operator=(const Field< Type > &)
Copy assignment.
Definition: Field.C:635
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Global function forwards to reuseTmpDimensionedField::New.
Definition: DimensionedFieldReuseFunctions.H:105
Foam::List
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition: BitOps.H:63
Foam::UList< Type >
Foam::List::clear
void clear()
Clear the list, i.e. set size to zero.
Definition: ListI.H:116
Foam::IndirectListBase
Base for lists with indirect addressing, templated on the list contents type and the addressing type....
Definition: IndirectListBase.H:56
Foam::Field::null
static const Field< Type > & null()
Return nullObject reference Field.
Definition: FieldI.H:31
Foam::zero
A class representing the concept of 0 (zero) that can be used to avoid manipulating objects known to ...
Definition: zero.H:62