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