src/postProcessing/foamCalcFunctions/basic/addSubtract/addSubtract.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 \*---------------------------------------------------------------------------*/
  26
  27 #include "addSubtract.H"
  28 #include "addToRunTimeSelectionTable.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34     namespace calcTypes
  35     {
  36         defineTypeNameAndDebug(addSubtract, 0);
  37         addToRunTimeSelectionTable(calcType, addSubtract, dictionary);
  38     }
  39 }
  40
  41
  42 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  43
  44 void Foam::calcTypes::addSubtract::writeAddSubtractFields
  45 (
  46     const Time& runTime,
  47     const fvMesh& mesh,
  48     const IOobject& baseFieldHeader
  49 )
  50 {
  51     bool processed = false;
  52
  53     IOobject addSubtractFieldHeader
  54     (
  55         addSubtractFieldName_,
  56         runTime.timeName(),
  57         mesh,
  58         IOobject::MUST_READ
  59     );
  60
  61     if (addSubtractFieldHeader.headerOk())
  62     {
  63         writeAddSubtractField<scalar>
  64         (
  65             baseFieldHeader,
  66             addSubtractFieldHeader,
  67             mesh,
  68             processed
  69         );
  70         writeAddSubtractField<vector>
  71         (
  72             baseFieldHeader,
  73             addSubtractFieldHeader,
  74             mesh,
  75             processed
  76         );
  77         writeAddSubtractField<sphericalTensor>
  78         (
  79             baseFieldHeader,
  80             addSubtractFieldHeader,
  81             mesh,
  82             processed
  83         );
  84         writeAddSubtractField<symmTensor>
  85         (
  86             baseFieldHeader,
  87             addSubtractFieldHeader,
  88             mesh,
  89             processed
  90         );
  91         writeAddSubtractField<tensor>
  92         (
  93             baseFieldHeader,
  94             addSubtractFieldHeader,
  95             mesh,
  96             processed
  97         );
  98
  99         if (!processed)
 100         {
 101             FatalError
 102                 << "Unable to process " << baseFieldName_
 103                 << " + " << addSubtractFieldName_ << nl
 104                 << "No call to addSubtract for fields of type "
 105                 << baseFieldHeader.headerClassName() << " + "
 106                 << addSubtractFieldHeader.headerClassName() << nl << nl
 107                 << exit(FatalError);
 108         }
 109     }
 110     else
 111     {
 112         FatalErrorIn("calcTypes::addSubtract::writeAddSubtractFields()")
 113             << "Unable to read addSubtract field: " << addSubtractFieldName_
 114             << nl << exit(FatalError);
 115     }
 116 }
 117
 118
 119 void Foam::calcTypes::addSubtract::writeAddSubtractValues
 120 (
 121     const Time& runTime,
 122     const fvMesh& mesh,
 123     const IOobject& baseFieldHeader
 124 )
 125 {
 126     bool processed = false;
 127
 128     writeAddSubtractValue<scalar>
 129     (
 130         baseFieldHeader,
 131         addSubtractValueStr_,
 132         mesh,
 133         processed
 134     );
 135     writeAddSubtractValue<vector>
 136     (
 137         baseFieldHeader,
 138         addSubtractValueStr_,
 139         mesh,
 140         processed
 141     );
 142     writeAddSubtractValue<sphericalTensor>
 143     (
 144         baseFieldHeader,
 145         addSubtractValueStr_,
 146         mesh,
 147         processed
 148     );
 149     writeAddSubtractValue<symmTensor>
 150     (
 151         baseFieldHeader,
 152         addSubtractValueStr_,
 153         mesh,
 154         processed
 155     );
 156     writeAddSubtractValue<tensor>
 157     (
 158         baseFieldHeader,
 159         addSubtractValueStr_,
 160         mesh,
 161         processed
 162     );
 163
 164     if (!processed)
 165     {
 166         FatalErrorIn("calcTypes::addSubtract::writeAddSubtractValue()")
 167             << "Unable to process " << baseFieldName_
 168             << " + " << addSubtractValueStr_ << nl
 169             << "No call to addSubtract for fields of type "
 170             << baseFieldHeader.headerClassName() << nl << nl
 171             << exit(FatalError);
 172     }
 173 }
 174
 175
 176 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 177
 178 Foam::calcTypes::addSubtract::addSubtract()
 179 :
 180     calcType(),
 181     baseFieldName_(""),
 182     calcType_(FIELD),
 183     addSubtractFieldName_(""),
 184     addSubtractValueStr_(""),
 185     resultName_(""),
 186     calcMode_(ADD)
 187 {}
 188
 189
 190 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 191
 192 Foam::calcTypes::addSubtract::~addSubtract()
 193 {}
 194
 195
 196 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 197
 198 void Foam::calcTypes::addSubtract::init()
 199 {
 200     argList::validArgs.append("add");
 201     argList::validArgs.append("baseField");
 202     argList::validArgs.append("calcMode");
 203     argList::validOptions.insert("field", "fieldName");
 204     argList::validOptions.insert("value", "valueString");
 205     argList::validOptions.insert("resultName", "fieldName");
 206 }
 207
 208
 209 void Foam::calcTypes::addSubtract::preCalc
 210 (
 211     const argList& args,
 212     const Time& runTime,
 213     const fvMesh& mesh
 214 )
 215 {
 216     baseFieldName_ = args.additionalArgs()[1];
 217     word calcModeName = args.additionalArgs()[2];
 218
 219     if (calcModeName == "add")
 220     {
 221         calcMode_ = ADD;
 222     }
 223     else if (calcModeName == "subtract")
 224     {
 225         calcMode_ = SUBTRACT;
 226     }
 227     else
 228     {
 229         FatalErrorIn("calcTypes::addSubtract::preCalc")
 230             << "Invalid calcMode: " << calcModeName << nl
 231             << "    Valid calcModes are add and subtract" << nl
 232             << exit(FatalError);
 233     }
 234
 235     if (args.optionFound("field"))
 236     {
 237         addSubtractFieldName_ = args.option("field");
 238         calcType_ = FIELD;
 239     }
 240     else if (args.optionFound("value"))
 241     {
 242         addSubtractValueStr_ = args.option("value");
 243         calcType_ = VALUE;
 244     }
 245     else
 246     {
 247         FatalErrorIn("calcTypes::addSubtract::preCalc")
 248             << "addSubtract requires either -field or -value option"
 249             << nl << exit(FatalError);
 250     }
 251
 252     if (args.optionFound("resultName"))
 253     {
 254         resultName_ = args.option("resultName");
 255     }
 256 }
 257
 258
 259 void Foam::calcTypes::addSubtract::calc
 260 (
 261     const argList& args,
 262     const Time& runTime,
 263     const fvMesh& mesh
 264 )
 265 {
 266     IOobject baseFieldHeader
 267     (
 268         baseFieldName_,
 269         runTime.timeName(),
 270         mesh,
 271         IOobject::MUST_READ
 272     );
 273
 274     if (baseFieldHeader.headerOk())
 275     {
 276         switch (calcType_)
 277         {
 278             case FIELD:
 279             {
 280                 writeAddSubtractFields(runTime, mesh, baseFieldHeader);
 281                 break;
 282             }
 283             case VALUE:
 284             {
 285                 writeAddSubtractValues(runTime, mesh, baseFieldHeader);
 286                 break;
 287             }
 288             default:
 289             {
 290                 FatalErrorIn("calcTypes::addSubtract::calc")
 291                     << "unknown calcType " << calcType_ << nl
 292                     << abort(FatalError);
 293             }
 294         }
 295     }
 296     else
 297     {
 298         FatalErrorIn("calcTypes::addSubtract::calc")
 299             << "Unable to read base field: " << baseFieldName_
 300             << nl << exit(FatalError);
 301     }
 302 }
 303
 304
 305 // ************************************************************************* //
 306