Newer
Older
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
Henry Weller
committed
\\ / A nd | Copyright (C) 2011-2016 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/>.
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
\*---------------------------------------------------------------------------*/
#include "GeometricFieldReuseFunctions.H"
#define TEMPLATE \
template<class Type, template<class> class PatchField, class GeoMesh>
#include "GeometricFieldFunctionsM.C"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
template<class Type, template<class> class PatchField, class GeoMesh>
void component
(
GeometricField
<
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>& gcf,
const GeometricField<Type, PatchField, GeoMesh>& gf,
const direction d
)
{
component(gcf.internalField(), gf.internalField(), d);
component(gcf.boundaryField(), gf.boundaryField(), d);
}
template<class Type, template<class> class PatchField, class GeoMesh>
void T
(
GeometricField<Type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& gf1
)
{
T(gf.internalField(), gf1.internalField());
T(gf.boundaryField(), gf1.boundaryField());
}
template
<
class Type,
template<class> class PatchField,
class GeoMesh,
direction r
>
void pow
(
GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& gf1
)
{
pow(gf.internalField(), gf1.internalField(), r);
pow(gf.boundaryField(), gf1.boundaryField(), r);
}
template
<
class Type,
template<class> class PatchField,
class GeoMesh,
direction r
>
Henry Weller
committed
tmp<GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>>
pow
(
const GeometricField<Type, PatchField, GeoMesh>& gf,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
Henry Weller
committed
tmp<GeometricField<powProductType, PatchField, GeoMesh>> tPow
(
new GeometricField<powProductType, PatchField, GeoMesh>
(
IOobject
(
"pow(" + gf.name() + ',' + name(r) + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
pow(gf.dimensions(), r)
)
);
pow<Type, r, PatchField, GeoMesh>(tPow.ref(), gf);
return tPow;
}
template
<
class Type,
template<class> class PatchField,
class GeoMesh,
direction r
>
Henry Weller
committed
tmp<GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>>
Henry Weller
committed
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
Henry Weller
committed
tmp<GeometricField<powProductType, PatchField, GeoMesh>> tPow
(
new GeometricField<powProductType, PatchField, GeoMesh>
(
IOobject
(
"pow(" + gf.name() + ',' + name(r) + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
pow(gf.dimensions(), r)
)
);
pow<Type, r, PatchField, GeoMesh>(tPow.ref(), gf);
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
tgf.clear();
return tPow;
}
template<class Type, template<class> class PatchField, class GeoMesh>
void sqr
(
GeometricField
<typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& gf1
)
{
sqr(gf.internalField(), gf1.internalField());
sqr(gf.boundaryField(), gf1.boundaryField());
}
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
<
GeometricField
<
typename outerProduct<Type, Type>::type,
PatchField,
GeoMesh
>
>
sqr(const GeometricField<Type, PatchField, GeoMesh>& gf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
Henry Weller
committed
tmp<GeometricField<outerProductType, PatchField, GeoMesh>> tSqr
(
new GeometricField<outerProductType, PatchField, GeoMesh>
(
IOobject
(
"sqr(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
sqr(gf.dimensions())
)
);
sqr(tSqr.ref(), gf);
return tSqr;
}
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
<
GeometricField
<
typename outerProduct<Type, Type>::type,
PatchField,
GeoMesh
>
>
Henry Weller
committed
sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
Henry Weller
committed
tmp<GeometricField<outerProductType, PatchField, GeoMesh>> tSqr
(
new GeometricField<outerProductType, PatchField, GeoMesh>
(
IOobject
(
"sqr(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
sqr(gf.dimensions())
)
);
sqr(tSqr.ref(), gf);
tgf.clear();
return tSqr;
}
template<class Type, template<class> class PatchField, class GeoMesh>
void magSqr
(
GeometricField<scalar, PatchField, GeoMesh>& gsf,
const GeometricField<Type, PatchField, GeoMesh>& gf
)
{
magSqr(gsf.internalField(), gf.internalField());
magSqr(gsf.boundaryField(), gf.boundaryField());
}
template<class Type, template<class> class PatchField, class GeoMesh>
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> magSqr
(
const GeometricField<Type, PatchField, GeoMesh>& gf
)
{
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> tMagSqr
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"magSqr(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
sqr(gf.dimensions())
)
);
magSqr(tMagSqr.ref(), gf);
return tMagSqr;
}
template<class Type, template<class> class PatchField, class GeoMesh>
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> magSqr
Henry Weller
committed
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
)
{
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> tMagSqr
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"magSqr(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
sqr(gf.dimensions())
)
);
magSqr(tMagSqr.ref(), gf);
tgf.clear();
return tMagSqr;
}
template<class Type, template<class> class PatchField, class GeoMesh>
void mag
(
GeometricField<scalar, PatchField, GeoMesh>& gsf,
const GeometricField<Type, PatchField, GeoMesh>& gf
)
{
mag(gsf.internalField(), gf.internalField());
mag(gsf.boundaryField(), gf.boundaryField());
}
template<class Type, template<class> class PatchField, class GeoMesh>
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> mag
(
const GeometricField<Type, PatchField, GeoMesh>& gf
)
{
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> tMag
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"mag(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
gf.dimensions()
)
);
mag(tMag.ref(), gf);
return tMag;
}
template<class Type, template<class> class PatchField, class GeoMesh>
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> mag
Henry Weller
committed
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
)
{
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
Henry Weller
committed
tmp<GeometricField<scalar, PatchField, GeoMesh>> tMag
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"mag(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
gf.dimensions()
)
);
mag(tMag.ref(), gf);
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
tgf.clear();
return tMag;
}
template<class Type, template<class> class PatchField, class GeoMesh>
void cmptAv
(
GeometricField
<
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>& gcf,
const GeometricField<Type, PatchField, GeoMesh>& gf
)
{
cmptAv(gcf.internalField(), gf.internalField());
cmptAv(gcf.boundaryField(), gf.boundaryField());
}
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
<
GeometricField
<
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>
>
cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf)
{
typedef typename GeometricField<Type, PatchField, GeoMesh>::cmptType
cmptType;
Henry Weller
committed
tmp<GeometricField<cmptType, PatchField, GeoMesh>> CmptAv
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"cmptAv(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
gf.dimensions()
)
);
cmptAv(CmptAv.ref(), gf);
return CmptAv;
}
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
<
GeometricField
<
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>
>
Henry Weller
committed
cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
typedef typename GeometricField<Type, PatchField, GeoMesh>::cmptType
cmptType;
const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
Henry Weller
committed
tmp<GeometricField<cmptType, PatchField, GeoMesh>> CmptAv
(
new GeometricField<scalar, PatchField, GeoMesh>
(
IOobject
(
"cmptAv(" + gf.name() + ')',
gf.instance(),
gf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
gf.mesh(),
gf.dimensions()
)
);
cmptAv(CmptAv.ref(), gf);
tgf.clear();
return CmptAv;
}
#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, gFunc) \
\
template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \
( \
const GeometricField<Type, PatchField, GeoMesh>& gf \
) \
{ \
return dimensioned<Type> \
( \
#func "(" + gf.name() + ')', \
gf.dimensions(), \
Foam::func(gFunc(gf.internalField()), gFunc(gf.boundaryField())) \
); \
} \
\
template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \
( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
) \
{ \
dimensioned<returnType> res = func(tgf1()); \
tgf1.clear(); \
return res; \
}
UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, max, gMax)
UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, min, gMin)
#undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
#define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc) \
\
template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \
( \
const GeometricField<Type, PatchField, GeoMesh>& gf \
) \
{ \
return dimensioned<Type> \
( \
#func "(" + gf.name() + ')', \
gf.dimensions(), \
gFunc(gf.internalField()) \
); \
} \
\
template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \
( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
) \
{ \
dimensioned<returnType> res = func(tgf1()); \
tgf1.clear(); \
return res; \
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
}
UNARY_REDUCTION_FUNCTION(Type, sum, gSum)
UNARY_REDUCTION_FUNCTION(scalar, sumMag, gSumMag)
UNARY_REDUCTION_FUNCTION(Type, average, gAverage)
#undef UNARY_REDUCTION_FUNCTION
BINARY_FUNCTION(Type, Type, Type, max)
BINARY_FUNCTION(Type, Type, Type, min)
BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION(Type, Type, Type, max)
BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform)
BINARY_OPERATOR(Type, Type, scalar, *, '*', multiply)
BINARY_OPERATOR(Type, scalar, Type, *, '*', multiply)
BINARY_OPERATOR(Type, Type, scalar, /, '|', divide)
BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, '*', multiply)
BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, '*', multiply)
BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
void opFunc \
( \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh>& gf, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
) \
{ \
Foam::opFunc(gf.internalField(), gf1.internalField(), gf2.internalField());\
Foam::opFunc(gf.boundaryField(), gf1.boundaryField(), gf2.boundaryField());\
} \
\
template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \
< \
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes \
( \
new GeometricField<productType, PatchField, GeoMesh> \
( \
IOobject \
( \
'(' + gf1.name() + #op + gf2.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
gf1.dimensions() op gf2.dimensions() \
) \
); \
\
Foam::opFunc(tRes.ref(), gf1, gf2); \
\
return tRes; \
} \
\
template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \
< \
Henry Weller
committed
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
\
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes = \
reuseTmpGeometricField<productType, Type2, PatchField, GeoMesh>::New \
( \
tgf2, \
'(' + gf1.name() + #op + gf2.name() + ')', \
gf1.dimensions() op gf2.dimensions() \
); \
\
Foam::opFunc(tRes.ref(), gf1, gf2); \
Henry Weller
committed
tgf2.clear(); \
\
return tRes; \
} \
\
template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \
< \
Henry Weller
committed
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
\
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes = \
reuseTmpGeometricField<productType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
'(' + gf1.name() + #op + gf2.name() + ')', \
gf1.dimensions() op gf2.dimensions() \
); \
\
Foam::opFunc(tRes.ref(), gf1, gf2); \
Henry Weller
committed
tgf1.clear(); \
\
return tRes; \
} \
\
template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \
< \
Henry Weller
committed
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
\
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes = \
reuseTmpTmpGeometricField \
<productType, Type1, Type1, Type2, PatchField, GeoMesh>::New \
( \
tgf1, \
tgf2, \
'(' + gf1.name() + #op + gf2.name() + ')', \
gf1.dimensions() op gf2.dimensions() \
); \
\
Foam::opFunc(tRes.ref(), gf1, gf2); \
Henry Weller
committed
tgf1.clear(); \
tgf2.clear(); \
\
return tRes; \
} \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \
( \
GeometricField \
<typename product<Type, Form>::type, PatchField, GeoMesh>& gf, \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \
const dimensioned<Form>& dvs \
) \
{ \
Foam::opFunc(gf.internalField(), gf1.internalField(), dvs.value()); \
Foam::opFunc(gf.boundaryField(), gf1.boundaryField(), dvs.value()); \
} \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
Henry Weller
committed
tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>> \
operator op \
( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \
const dimensioned<Form>& dvs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes \
( \
new GeometricField<productType, PatchField, GeoMesh> \
( \
IOobject \
( \
'(' + gf1.name() + #op + dvs.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
gf1.dimensions() op dvs.dimensions() \
) \
); \
\
Foam::opFunc(tRes.ref(), gf1, dvs); \
\
return tRes; \
} \
\
template \
< \
class Form, \
class Cmpt, \
direction nCmpt, \
class Type, template<class> class PatchField, \
class GeoMesh \
> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \
( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
return gf1 op dimensioned<Form>(static_cast<const Form&>(vs)); \
} \
\
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
Henry Weller
committed
tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>> \
operator op \
( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1, \
const dimensioned<Form>& dvs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
\
const GeometricField<Type, PatchField, GeoMesh>& gf1 = tgf1(); \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes = \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh>::New \
( \
tgf1, \
'(' + gf1.name() + #op + dvs.name() + ')', \
gf1.dimensions() op dvs.dimensions() \
); \
\
Foam::opFunc(tRes.ref(), gf1, dvs); \
Henry Weller
committed
tgf1.clear(); \
\
return tRes; \
} \
\
template \
< \
class Form, \
class Cmpt, \
direction nCmpt, \
class Type, template<class> class PatchField, \
class GeoMesh \
> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
operator op \
( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
return tgf1 op dimensioned<Form>(static_cast<const Form&>(vs)); \
} \
\
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \
( \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh>& gf, \
const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
) \
{ \
Foam::opFunc(gf.internalField(), dvs.value(), gf1.internalField()); \
Foam::opFunc(gf.boundaryField(), dvs.value(), gf1.boundaryField()); \
} \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes \
( \
new GeometricField<productType, PatchField, GeoMesh> \
( \
IOobject \
( \
'(' + dvs.name() + #op + gf1.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
dvs.dimensions() op gf1.dimensions() \
) \
); \
\
Foam::opFunc(tRes.ref(), dvs, gf1); \
\
return tRes; \
} \
\
template \
< \
class Form, \
class Cmpt, \
direction nCmpt, \
class Type, template<class> class PatchField, \
class GeoMesh \
> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
) \
{ \
return dimensioned<Form>(static_cast<const Form&>(vs)) op gf1; \
} \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
\
const GeometricField<Type, PatchField, GeoMesh>& gf1 = tgf1(); \
\
tmp<GeometricField<productType, PatchField, GeoMesh>> tRes = \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh>::New \
( \
tgf1, \
'(' + dvs.name() + #op + gf1.name() + ')', \
dvs.dimensions() op gf1.dimensions() \
); \
\
Foam::opFunc(tRes.ref(), dvs, gf1); \
Henry Weller
committed
tgf1.clear(); \
\
return tRes; \
} \
\
template \
< \
class Form, \
class Cmpt, \
direction nCmpt, \
class Type, template<class> class PatchField, \
class GeoMesh \
> \
Henry Weller
committed
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
) \
{ \
return dimensioned<Form>(static_cast<const Form&>(vs)) op tgf1; \
}
PRODUCT_OPERATOR(typeOfSum, +, add)
PRODUCT_OPERATOR(typeOfSum, -, subtract)
PRODUCT_OPERATOR(outerProduct, *, outer)
PRODUCT_OPERATOR(crossProduct, ^, cross)
PRODUCT_OPERATOR(innerProduct, &, dot)
PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
#undef PRODUCT_OPERATOR
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "undefFieldFunctionsM.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //