src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.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 "fieldMinMax.H"
  27 #include "volFields.H"
  28 #include "dictionary.H"
  29 #include "Time.H"
  30
  31
  32 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  33
  34 defineTypeNameAndDebug(Foam::fieldMinMax, 0);
  35
  36 namespace Foam
  37 {
  38     template<>
  39     const char* Foam::NamedEnum
  40     <
  41         Foam::fieldMinMax::modeType,
  42         2
  43     >::names[] =
  44     {
  45         "magnitude",
  46         "component"
  47     };
  48 }
  49
  50
  51 const Foam::NamedEnum<Foam::fieldMinMax::modeType, 2>
  52 Foam::fieldMinMax::modeTypeNames_;
  53
  54
  55 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  56
  57 Foam::fieldMinMax::fieldMinMax
  58 (
  59     const word& name,
  60     const objectRegistry& obr,
  61     const dictionary& dict,
  62     const bool loadFromFiles
  63 )
  64 :
  65     name_(name),
  66     obr_(obr),
  67     active_(true),
  68     write_(true),
  69     log_(false),
  70     mode_(mdMag),
  71     fieldSet_(),
  72     fieldMinMaxFilePtr_(NULL)
  73 {
  74     // Check if the available mesh is an fvMesh otherise deactivate
  75     if (!isA<fvMesh>(obr_))
  76     {
  77         active_ = false;
  78         WarningIn
  79         (
  80             "fieldMinMax::fieldMinMax"
  81             "(const objectRegistry& obr, const dictionary& dict)"
  82         )   << "No fvMesh available, deactivating."
  83             << endl;
  84     }
  85
  86     read(dict);
  87 }
  88
  89
  90 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  91
  92 Foam::fieldMinMax::~fieldMinMax()
  93 {}
  94
  95
  96 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  97
  98 void Foam::fieldMinMax::read(const dictionary& dict)
  99 {
 100     if (active_)
 101     {
 102         write_ = dict.lookupOrDefault<Switch>("write", true);
 103         log_ = dict.lookupOrDefault<Switch>("log", false);
 104
 105         mode_ = modeTypeNames_[dict.lookupOrDefault<word>("mode", "magnitude")];
 106         dict.lookup("fields") >> fieldSet_;
 107     }
 108 }
 109
 110
 111 void Foam::fieldMinMax::makeFile()
 112 {
 113     // Create the fieldMinMax file if not already created
 114     if (fieldMinMaxFilePtr_.empty())
 115     {
 116         if (debug)
 117         {
 118             Info<< "Creating fieldMinMax file." << endl;
 119         }
 120
 121         // File update
 122         if (Pstream::master())
 123         {
 124             fileName fieldMinMaxDir;
 125             if (Pstream::parRun())
 126             {
 127                 // Put in undecomposed case (Note: gives problems for
 128                 // distributed data running)
 129                 fieldMinMaxDir =
 130                     obr_.time().path()/".."/name_/obr_.time().timeName();
 131             }
 132             else
 133             {
 134                 fieldMinMaxDir =
 135                     obr_.time().path()/name_/obr_.time().timeName();
 136             }
 137
 138             // Create directory if does not exist.
 139             mkDir(fieldMinMaxDir);
 140
 141             // Open new file at start up
 142             fieldMinMaxFilePtr_.reset
 143             (
 144                 new OFstream(fieldMinMaxDir/(type() + ".dat"))
 145             );
 146
 147             // Add headers to output data
 148             writeFileHeader();
 149         }
 150     }
 151 }
 152
 153
 154 void Foam::fieldMinMax::writeFileHeader()
 155 {
 156     if (fieldMinMaxFilePtr_.valid())
 157     {
 158         fieldMinMaxFilePtr_()
 159             << "# Time" << tab << "field" << tab << "min" << tab << "max"
 160             << endl;
 161     }
 162 }
 163
 164
 165 void Foam::fieldMinMax::execute()
 166 {
 167     // Do nothing - only valid on write
 168 }
 169
 170
 171 void Foam::fieldMinMax::end()
 172 {
 173     // Do nothing - only valid on write
 174 }
 175
 176
 177 void Foam::fieldMinMax::write()
 178 {
 179     if (active_)
 180     {
 181         // Create the fieldMinMax file if not already created
 182         if (write_)
 183         {
 184             makeFile();
 185         }
 186
 187         forAll(fieldSet_, fieldI)
 188         {
 189             calcMinMaxFields<scalar>(fieldSet_[fieldI]);
 190             calcMinMaxFields<vector>(fieldSet_[fieldI]);
 191             calcMinMaxFields<sphericalTensor>(fieldSet_[fieldI]);
 192             calcMinMaxFields<symmTensor>(fieldSet_[fieldI]);
 193             calcMinMaxFields<tensor>(fieldSet_[fieldI]);
 194         }
 195     }
 196 }
 197
 198
 199 template<>
 200 void Foam::fieldMinMax::calcMinMaxFields<Foam::scalar>
 201 (
 202     const word& fieldName
 203 )
 204 {
 205     if (obr_.foundObject<volScalarField>(fieldName))
 206     {
 207         const volScalarField& field =
 208             obr_.lookupObject<volScalarField>(fieldName);
 209         const scalar minValue = min(field).value();
 210         const scalar maxValue = max(field).value();
 211
 212         if (Pstream::master())
 213         {
 214             if (write_)
 215             {
 216                 fieldMinMaxFilePtr_()
 217                     << obr_.time().value() << tab
 218                     << fieldName << tab << minValue << tab << maxValue << endl;
 219             }
 220
 221             if (log_)
 222             {
 223                 Info<< "fieldMinMax output:" << nl
 224                     << "    min(" << fieldName << ") = " << minValue << nl
 225                     << "    max(" << fieldName << ") = " << maxValue << nl
 226                     << endl;
 227             }
 228         }
 229     }
 230 }
 231
 232
 233 // ************************************************************************* //