src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-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 Description
  25     High performance macro functions for Field\<Type\> algebra.  These expand
  26     using either array element access (for vector machines) or pointer
  27     dereferencing for scalar machines as appropriate.
  28
  29 \*---------------------------------------------------------------------------*/
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 #define UNARY_FUNCTION(ReturnType, Type1, Func)                               \
  34                                                                               \
  35 TEMPLATE                                                                      \
  36 void Func(Field<ReturnType>& res, const UList<Type1>& f);                     \
  37 TEMPLATE                                                                      \
  38 tmp<Field<ReturnType> > Func(const UList<Type1>& f);                          \
  39 TEMPLATE                                                                      \
  40 tmp<Field<ReturnType> > Func(const tmp<Field<Type1> >& tf);
  41
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc)                         \
  46                                                                               \
  47 TEMPLATE                                                                      \
  48 void OpFunc(Field<ReturnType>& res, const UList<Type1>& f);                   \
  49 TEMPLATE                                                                      \
  50 tmp<Field<ReturnType> > operator Op(const UList<Type1>& f);                   \
  51 TEMPLATE                                                                      \
  52 tmp<Field<ReturnType> > operator Op(const tmp<Field<Type1> >& tf);
  53
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                       \
  58                                                                               \
  59 TEMPLATE                                                                      \
  60 void Func                                                                     \
  61 (                                                                             \
  62     Field<ReturnType>& f,                                                     \
  63     const UList<Type1>& f1,                                                   \
  64     const UList<Type2>& f2                                                    \
  65 );                                                                            \
  66                                                                               \
  67 TEMPLATE                                                                      \
  68 tmp<Field<ReturnType> > Func                                                  \
  69 (                                                                             \
  70     const UList<Type1>& f1,                                                   \
  71     const UList<Type2>& f2                                                    \
  72 );                                                                            \
  73                                                                               \
  74 TEMPLATE                                                                      \
  75 tmp<Field<ReturnType> > Func                                                  \
  76 (                                                                             \
  77     const UList<Type1>& f1,                                                   \
  78     const tmp<Field<Type2> >& tf2                                             \
  79 );                                                                            \
  80                                                                               \
  81 TEMPLATE                                                                      \
  82 tmp<Field<ReturnType> > Func                                                  \
  83 (                                                                             \
  84     const tmp<Field<Type1> >& tf1,                                            \
  85     const UList<Type2>& f2                                                    \
  86 );                                                                            \
  87                                                                               \
  88 TEMPLATE                                                                      \
  89 tmp<Field<ReturnType> > Func                                                  \
  90 (                                                                             \
  91     const tmp<Field<Type1> >& tf1,                                            \
  92     const tmp<Field<Type2> >& tf2                                             \
  93 );
  94
  95
  96 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  97
  98 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)               \
  99                                                                               \
 100 TEMPLATE                                                                      \
 101 void Func                                                                     \
 102 (                                                                             \
 103     Field<ReturnType>& f,                                                     \
 104     const Type1& s1,                                                          \
 105     const UList<Type2>& f2                                                    \
 106 );                                                                            \
 107                                                                               \
 108 TEMPLATE                                                                      \
 109 tmp<Field<ReturnType> > Func                                                  \
 110 (                                                                             \
 111     const Type1& s1,                                                          \
 112     const UList<Type2>& f2                                                    \
 113 );                                                                            \
 114                                                                               \
 115 TEMPLATE                                                                      \
 116 tmp<Field<ReturnType> > Func                                                  \
 117 (                                                                             \
 118     const Type1& s1,                                                          \
 119     const tmp<Field<Type2> >& tf2                                             \
 120 );
 121
 122
 123 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)               \
 124                                                                               \
 125 TEMPLATE                                                                      \
 126 void Func                                                                     \
 127 (                                                                             \
 128     Field<ReturnType>& f,                                                     \
 129     const UList<Type1>& f1,                                                   \
 130     const Type2& s2                                                           \
 131 );                                                                            \
 132                                                                               \
 133 TEMPLATE                                                                      \
 134 tmp<Field<ReturnType> > Func                                                  \
 135 (                                                                             \
 136     const UList<Type1>& f1,                                                   \
 137     const Type2& s2                                                           \
 138 );                                                                            \
 139                                                                               \
 140 TEMPLATE                                                                      \
 141 tmp<Field<ReturnType> > Func                                                  \
 142 (                                                                             \
 143     const tmp<Field<Type1> >& tf1,                                            \
 144     const Type2& s2                                                           \
 145 );
 146
 147
 148 #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)                  \
 149     BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                   \
 150     BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
 151
 152
 153 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 154
 155 #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc)                 \
 156                                                                               \
 157 TEMPLATE                                                                      \
 158 void OpFunc                                                                   \
 159 (                                                                             \
 160     Field<ReturnType>& f,                                                     \
 161     const UList<Type1>& f1,                                                   \
 162     const UList<Type2>& f2                                                    \
 163 );                                                                            \
 164                                                                               \
 165 TEMPLATE                                                                      \
 166 tmp<Field<ReturnType> > operator Op                                           \
 167 (                                                                             \
 168     const UList<Type1>& f1,                                                   \
 169     const UList<Type2>& f2                                                    \
 170 );                                                                            \
 171                                                                               \
 172 TEMPLATE                                                                      \
 173 tmp<Field<ReturnType> > operator Op                                           \
 174 (                                                                             \
 175     const UList<Type1>& f1,                                                   \
 176     const tmp<Field<Type2> >& tf2                                             \
 177 );                                                                            \
 178                                                                               \
 179 TEMPLATE                                                                      \
 180 tmp<Field<ReturnType> > operator Op                                           \
 181 (                                                                             \
 182     const tmp<Field<Type1> >& tf1,                                            \
 183     const UList<Type2>& f2                                                    \
 184 );                                                                            \
 185                                                                               \
 186 TEMPLATE                                                                      \
 187 tmp<Field<ReturnType> > operator Op                                           \
 188 (                                                                             \
 189     const tmp<Field<Type1> >& tf1,                                            \
 190     const tmp<Field<Type2> >& tf2                                             \
 191 );
 192
 193
 194 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 195
 196 #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc)         \
 197                                                                               \
 198 TEMPLATE                                                                      \
 199 void OpFunc                                                                   \
 200 (                                                                             \
 201     Field<ReturnType>& f,                                                     \
 202     const Type1& s1,                                                          \
 203     const UList<Type2>& f2                                                    \
 204 );                                                                            \
 205                                                                               \
 206 TEMPLATE                                                                      \
 207 tmp<Field<ReturnType> > operator Op                                           \
 208 (                                                                             \
 209     const Type1& s1,                                                          \
 210     const UList<Type2>& f2                                                    \
 211 );                                                                            \
 212                                                                               \
 213 TEMPLATE                                                                      \
 214 tmp<Field<ReturnType> > operator Op                                           \
 215 (                                                                             \
 216     const Type1& s1,                                                          \
 217     const tmp<Field<Type2> >& tf2                                             \
 218 );
 219
 220
 221 #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)         \
 222                                                                               \
 223 TEMPLATE                                                                      \
 224 void OpFunc                                                                   \
 225 (                                                                             \
 226     Field<ReturnType>& f,                                                     \
 227     const UList<Type1>& f1,                                                   \
 228     const Type2& s2                                                           \
 229 );                                                                            \
 230                                                                               \
 231 TEMPLATE                                                                      \
 232 tmp<Field<ReturnType> > operator Op                                           \
 233 (                                                                             \
 234     const UList<Type1>& f1,                                                   \
 235     const Type2& s2                                                           \
 236 );                                                                            \
 237                                                                               \
 238 TEMPLATE                                                                      \
 239 tmp<Field<ReturnType> > operator Op                                           \
 240 (                                                                             \
 241     const tmp<Field<Type1> >& tf1,                                            \
 242     const Type2& s2                                                           \
 243 );
 244
 245
 246 #define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc)            \
 247     BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc)             \
 248     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 249
 250
 251 // ************************************************************************* //