applications/utilities/preProcessing/setFields/setFields.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Selects a cell set through a dictionary.
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "argList.H"
  30 #include "timeSelector.H"
  31 #include "objectRegistry.H"
  32 #include "foamTime.H"
  33 #include "fvMesh.H"
  34 #include "topoSetSource.H"
  35 #include "cellSet.H"
  36 #include "volFields.H"
  37
  38 using namespace Foam;
  39
  40 template<class GeoField>
  41 void setFieldType
  42 (
  43     const fvMesh& mesh,
  44     const labelList& selectedCells,
  45     Istream& fieldValueStream
  46 )
  47 {
  48     // Read field and value together; otherwise there will be an input error
  49     // when a field is not found.  HJ, 3/Aug/2011
  50     word fieldName(fieldValueStream);
  51
  52     typename GeoField::value_type value
  53     (
  54         static_cast<const typename GeoField::value_type&>
  55         (
  56             pTraits<typename GeoField::value_type>(fieldValueStream)
  57         )
  58     );
  59
  60     IOobject fieldHeader
  61     (
  62         fieldName,
  63         mesh.time().timeName(),
  64         mesh,
  65         IOobject::MUST_READ
  66     );
  67
  68     // Check field exists
  69     if (fieldHeader.headerOk())
  70     {
  71         Info<< "    Setting " << fieldHeader.headerClassName()
  72             << " " << fieldName << endl;
  73
  74         GeoField field(fieldHeader, mesh);
  75
  76         if (selectedCells.size() == field.size())
  77         {
  78             field.internalField() = value;
  79         }
  80         else
  81         {
  82             forAll (selectedCells, celli)
  83             {
  84                 field[selectedCells[celli]] = value;
  85             }
  86         }
  87
  88         forAll (field.boundaryField(), patchi)
  89         {
  90             // Forced patch assignment.  HJ, 1/Aug/2010
  91             field.boundaryField()[patchi] ==
  92                 field.boundaryField()[patchi].patchInternalField();
  93         }
  94
  95         field.write();
  96     }
  97     else
  98     {
  99         WarningIn
 100         (
 101             "void setFieldType"
 102             "(const fvMesh& mesh, const labelList& selectedCells,"
 103             "Istream& fieldValueStream)"
 104         ) << "Field " << fieldName << " not found" << endl;
 105     }
 106 }
 107
 108
 109 class setField
 110 {
 111
 112 public:
 113
 114     setField()
 115     {}
 116
 117     autoPtr<setField> clone() const
 118     {
 119         return autoPtr<setField>(new setField());
 120     }
 121
 122     class iNew
 123     {
 124         const fvMesh& mesh_;
 125         const labelList& selectedCells_;
 126
 127     public:
 128
 129         iNew(const fvMesh& mesh, const labelList& selectedCells)
 130         :
 131             mesh_(mesh),
 132             selectedCells_(selectedCells)
 133         {}
 134
 135         autoPtr<setField> operator()(Istream& fieldValues) const
 136         {
 137             word fieldType(fieldValues);
 138
 139             if (fieldType == "volScalarFieldValue")
 140             {
 141                 setFieldType<volScalarField>
 142                     (mesh_, selectedCells_, fieldValues);
 143             }
 144             else if (fieldType == "volVectorFieldValue")
 145             {
 146                 setFieldType<volVectorField>
 147                     (mesh_, selectedCells_, fieldValues);
 148             }
 149             else if (fieldType == "volSphericalTensorFieldValue")
 150             {
 151                 setFieldType<volSphericalTensorField>
 152                     (mesh_, selectedCells_, fieldValues);
 153             }
 154             else if (fieldType == "volSymmTensorFieldValue")
 155             {
 156                 setFieldType<volSymmTensorField>
 157                     (mesh_, selectedCells_, fieldValues);
 158             }
 159             else if (fieldType == "volTensorFieldValue")
 160             {
 161                 setFieldType<volTensorField>
 162                     (mesh_, selectedCells_, fieldValues);
 163             }
 164             else
 165             {
 166                 WarningIn("setField::iNew::operator()(Istream& is)")
 167                     << "field type " << fieldType << " not currently supported"
 168                     << endl;
 169             }
 170
 171             return autoPtr<setField>(new setField());
 172         }
 173     };
 174 };
 175
 176
 177 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 178
 179 int main(int argc, char *argv[])
 180 {
 181 #   include "setRootCase.H"
 182 #   include "createTime.H"
 183
 184     Info<< "Time = " << runTime.timeName() << endl;
 185
 186 #   include "createMesh.H"
 187
 188     Info<< "Reading setFieldsDict\n" << endl;
 189
 190     IOdictionary setFieldsDict
 191     (
 192         IOobject
 193         (
 194             "setFieldsDict",
 195             runTime.system(),
 196             mesh,
 197             IOobject::MUST_READ,
 198             IOobject::NO_WRITE
 199         )
 200     );
 201
 202     if (setFieldsDict.found("defaultFieldValues"))
 203     {
 204         Info<< "Setting field default values" << endl;
 205         PtrList<setField> defaultFieldValues
 206         (
 207             setFieldsDict.lookup("defaultFieldValues"),
 208             setField::iNew(mesh, labelList(mesh.nCells()))
 209         );
 210         Info<< endl;
 211     }
 212
 213
 214     Info<< "Setting field region values" << endl;
 215
 216     PtrList<entry> regions(setFieldsDict.lookup("regions"));
 217
 218     forAll (regions, regionI)
 219     {
 220         const entry& region = regions[regionI];
 221
 222         autoPtr<topoSetSource> cellSelector =
 223             topoSetSource::New(region.keyword(), mesh, region.dict());
 224
 225         cellSet selectedCellSet
 226         (
 227             mesh,
 228             "cellSet",
 229             mesh.nCells()/10+1  // Reasonable size estimate.
 230         );
 231
 232         cellSelector->applyToSet
 233         (
 234             topoSetSource::NEW,
 235             selectedCellSet
 236         );
 237
 238         PtrList<setField> fieldValues
 239         (
 240             region.dict().lookup("fieldValues"),
 241             setField::iNew(mesh, selectedCellSet.toc())
 242         );
 243     }
 244
 245     Info<< "\nEnd" << endl;
 246
 247     return 0;
 248 }
 249
 250
 251 // ************************************************************************* //