File size: 7,029 Bytes
5a600cf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 | /*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2026 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::PtrField
Description
Field of objects which are dynamically allocated and stored in a PtrList
SourceFiles
PtrField.C
\*---------------------------------------------------------------------------*/
#ifndef PtrField_H
#define PtrField_H
#include "tmp.H"
#include "PtrList.H"
#include "expressionExpressionable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class PtrField Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class PtrField
:
public tmp<PtrField<Type>>::refCount,
public PtrList<Type>
{
public:
// Public Types
//- Primitive type
using pType = typename Type::pType;
//- Primitive component type
using pCmptType = typename Type::pCmptType;
//- Component type
using cmptType = typename Type::cmptType;
//- Component Field type
using cmptField = typename Type::cmptField;
// Constructors
//- Construct null
// Used for temporary fields which are initialised after construction
PtrField();
//- Construct given size
// Used for temporary fields which are initialised after construction
explicit PtrField(const label);
//- Copy constructor
PtrField(const PtrField<Type>&);
//- Move constructor
PtrField(PtrField<Type>&&);
//- Construct as copy of tmp<PtrField>
PtrField(const tmp<PtrField<Type>>&);
//- Construct as copy of a PtrField<Type> with optional clone arguments
template<class ... Args>
explicit PtrField(const PtrField<Type>&, const Args& ... args);
//- Construct as copy of a PtrList<Type> with optional clone arguments
template<class ... Args>
explicit PtrField(const PtrList<Type>&, const Args& ... args);
//- Construct from an expression with optional New selector arguments
template
<
class Expression,
class ... Args,
class = EnableIfExpression<Expression>
>
explicit PtrField(const Expression& e, const Args& ... args);
//- Clone
tmp<PtrField<Type>> clone() const;
//- If the argument is a temporary return
// otherwise construct a copy by calling New for each element
template<class ... Args>
static tmp<PtrField<Type>> New
(
const tmp<PtrField<Type>>& tf,
const Args& ... args
);
// Member Functions
//- Negate this field
void negate();
//- Return a component field expression of the field
inline auto component(const direction&) const;
//- Replace a component field of the field
void replace(const direction, const PtrField<cmptField>&);
//- Replace a component field of the field from an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void replace(const direction, const Expression&);
//- Replace a component field of the field
void replace(const direction, const cmptType&);
//- Return the field transpose expression
// (only defined for second rank tensors)
inline auto T() const;
//- Bound the field to the given lower bound
void boundLower(const pType& lower);
//- Bound the field to the given upper bound
void boundUpper(const pType& upper);
//- Bound the field within the given lower and upper bounds
void bound(const pType& lower, const pType& upper);
// Member Operators
void operator=(const PtrField<Type>&);
void operator=(PtrField<Type>&&);
void operator=(const tmp<PtrField<Type>>&);
//- Assign to an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void operator=(const Expression& e);
void operator=(const pType&);
void operator+=(const PtrField<Type>&);
void operator+=(const tmp<PtrField<Type>>&);
//- Assign-add to an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void operator+=(const Expression& e);
void operator+=(const pType&);
void operator-=(const PtrField<Type>&);
void operator-=(const tmp<PtrField<Type>>&);
//- Assign-subtract to an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void operator-=(const Expression& e);
void operator-=(const pType&);
void operator*=(const PtrField<cmptField>&);
void operator*=(const tmp<PtrField<cmptField>>&);
//- Assign-multiply to an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void operator*=(const Expression& e);
void operator*=(const pCmptType&);
void operator/=(const PtrField<cmptField>&);
void operator/=(const tmp<PtrField<cmptField>>&);
//- Assign-divide to an expression
template<class Expression, class = EnableIfExpressionable<Expression>>
void operator/=(const Expression& e);
void operator/=(const pCmptType&);
};
template<class Type>
Ostream& operator<<(Ostream&, const PtrField<Type>&);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "PtrFieldExpression.H"
#ifdef NoRepository
#include "PtrField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
|