src/OpenFOAM/fields/Fields/complexFields/complexFields.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Description
  26     Specialisation of Field\<T\> for complex and complexVector.
  27
  28 \*---------------------------------------------------------------------------*/
  29
  30 #include "complexFields.H"
  31 #include "addToRunTimeSelectionTable.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37
  38 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  39
  40 defineCompoundTypeName(List<complex>, complexList);
  41 addCompoundToRunTimeSelectionTable(List<complex>, complexList);
  42
  43 complexField ComplexField(const UList<scalar>& re, const UList<scalar>& im)
  44 {
  45     complexField cf(re.size());
  46
  47     forAll(cf, i)
  48     {
  49         cf[i].Re() = re[i];
  50         cf[i].Im() = im[i];
  51     }
  52
  53     return cf;
  54 }
  55
  56
  57 complexField ReComplexField(const UList<scalar>& sf)
  58 {
  59     complexField cf(sf.size());
  60
  61     forAll(cf, i)
  62     {
  63         cf[i].Re() = sf[i];
  64         cf[i].Im() = 0.0;
  65     }
  66
  67     return cf;
  68 }
  69
  70
  71 complexField ImComplexField(const UList<scalar>& sf)
  72 {
  73     complexField cf(sf.size());
  74
  75     forAll(cf, i)
  76     {
  77         cf[i].Re() = 0.0;
  78         cf[i].Im() = sf[i];
  79     }
  80
  81     return cf;
  82 }
  83
  84
  85 scalarField ReImSum(const UList<complex>& cf)
  86 {
  87     scalarField sf(cf.size());
  88
  89     forAll(sf, i)
  90     {
  91         sf[i] = cf[i].Re() + cf[i].Im();
  92     }
  93
  94     return sf;
  95 }
  96
  97
  98 scalarField Re(const UList<complex>& cf)
  99 {
 100     scalarField sf(cf.size());
 101
 102     forAll(sf, i)
 103     {
 104         sf[i] = cf[i].Re();
 105     }
 106
 107     return sf;
 108 }
 109
 110
 111 scalarField Im(const UList<complex>& cf)
 112 {
 113     scalarField sf(cf.size());
 114
 115     forAll(sf, i)
 116     {
 117         sf[i] = cf[i].Im();
 118     }
 119
 120     return sf;
 121 }
 122
 123
 124 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 125
 126 defineCompoundTypeName(List<complexVector>, complexVectorList);
 127 addCompoundToRunTimeSelectionTable(List<complexVector>, complexVectorList);
 128
 129 complexVectorField ComplexField(const UList<vector>& re, const UList<vector>& im)
 130 {
 131     complexVectorField cvf(re.size());
 132
 133     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 134     {
 135         forAll(cvf, i)
 136         {
 137             cvf[i].component(cmpt).Re() = re[i].component(cmpt);
 138             cvf[i].component(cmpt).Im() = im[i].component(cmpt);
 139         }
 140     }
 141
 142     return cvf;
 143 }
 144
 145
 146 complexVectorField ReComplexField(const UList<vector>& vf)
 147 {
 148     complexVectorField cvf(vf.size());
 149
 150     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 151     {
 152         forAll(cvf, i)
 153         {
 154             cvf[i].component(cmpt).Re() = vf[i].component(cmpt);
 155             cvf[i].component(cmpt).Im() = 0.0;
 156         }
 157     }
 158
 159     return cvf;
 160 }
 161
 162
 163 complexVectorField ImComplexField(const UList<vector>& vf)
 164 {
 165     complexVectorField cvf(vf.size());
 166
 167     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 168     {
 169         forAll(cvf, i)
 170         {
 171             cvf[i].component(cmpt).Re() = 0.0;
 172             cvf[i].component(cmpt).Im() = vf[i].component(cmpt);
 173         }
 174     }
 175
 176     return cvf;
 177 }
 178
 179
 180 vectorField ReImSum(const UList<complexVector>& cvf)
 181 {
 182     vectorField vf(cvf.size());
 183
 184     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 185     {
 186         forAll(cvf, i)
 187         {
 188             vf[i].component(cmpt) =
 189                 cvf[i].component(cmpt).Re() + cvf[i].component(cmpt).Im();
 190         }
 191     }
 192
 193     return vf;
 194 }
 195
 196
 197 vectorField Re(const UList<complexVector>& cvf)
 198 {
 199     vectorField vf(cvf.size());
 200
 201     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 202     {
 203         forAll(cvf, i)
 204         {
 205             vf[i].component(cmpt) = cvf[i].component(cmpt).Re();
 206         }
 207     }
 208
 209     return vf;
 210 }
 211
 212
 213 vectorField Im(const UList<complexVector>& cvf)
 214 {
 215     vectorField vf(cvf.size());
 216
 217     for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
 218     {
 219         forAll(cvf, i)
 220         {
 221             vf[i].component(cmpt) = cvf[i].component(cmpt).Im();
 222         }
 223     }
 224
 225     return vf;
 226 }
 227
 228
 229 complexVectorField operator^
 230 (
 231     const UList<vector>& vf,
 232     const UList<complexVector>& cvf
 233 )
 234 {
 235     return ComplexField(vf^Re(cvf), vf^Im(cvf));
 236 }
 237
 238
 239 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 240
 241 } // End namespace Foam
 242
 243 // ************************************************************************* //