src/sampling/probes/probes.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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
  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 Class
  25     Foam::probes
  26
  27 Description
  28     Set of locations to sample.
  29
  30     Call write() to sample and write files.
  31
  32 SourceFiles
  33     probes.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef probes_H
  38 #define probes_H
  39
  40 #include "HashPtrTable.H"
  41 #include "OFstream.H"
  42 #include "polyMesh.H"
  43 #include "pointField.H"
  44 #include "volFieldsFwd.H"
  45
  46 #include "wordReList.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // Forward declaration of classes
  54 class objectRegistry;
  55 class dictionary;
  56 class fvMesh;
  57 class mapPolyMesh;
  58
  59 /*---------------------------------------------------------------------------*\
  60                           Class probes Declaration
  61 \*---------------------------------------------------------------------------*/
  62
  63 class probes
  64 :
  65     public pointField
  66 {
  67 protected:
  68
  69     // Protected classes
  70
  71         //- Class used for grouping field types
  72         template<class Type>
  73         class fieldGroup
  74         :
  75             public DynamicList<word>
  76         {
  77         public:
  78             //- Construct null
  79             fieldGroup()
  80             :
  81                 DynamicList<word>(0)
  82             {}
  83
  84         };
  85
  86
  87     // Private data
  88
  89         //- Name of this set of probes,
  90         //  Also used as the name of the probes directory.
  91         word name_;
  92
  93         //- Const reference to fvMesh
  94         const fvMesh& mesh_;
  95
  96         //- Load fields from files (not from objectRegistry)
  97         bool loadFromFiles_;
  98
  99
 100         // Read from dictonary
 101
 102             //- Names of fields to probe
 103             wordReList fieldSelection_;
 104
 105         // Calculated
 106
 107             //- Categorized scalar/vector/tensor fields
 108             fieldGroup<scalar> scalarFields_;
 109             fieldGroup<vector> vectorFields_;
 110             fieldGroup<sphericalTensor> sphericalTensorFields_;
 111             fieldGroup<symmTensor> symmTensorFields_;
 112             fieldGroup<tensor> tensorFields_;
 113
 114             // Cells to be probed (obtained from the locations)
 115             labelList elementList_;
 116
 117             //- Current open files
 118             HashPtrTable<OFstream> probeFilePtrs_;
 119
 120
 121     // Private Member Functions
 122
 123         //- Clear old field groups
 124         void clearFieldGroups();
 125
 126         //- Append fieldName to the appropriate group
 127         label appendFieldGroup(const word& fieldName, const word& fieldType);
 128
 129         //- Classify field types, returns the number of fields
 130         label classifyFields();
 131
 132         //- Find cells containing probes
 133         virtual void findElements(const fvMesh&);
 134
 135         //- Classify field type and Open/close file streams,
 136         //  returns number of fields
 137         label prepare();
 138
 139 private:
 140
 141         //- Sample and write a particular volume field
 142         template<class Type>
 143         void sampleAndWrite
 144         (
 145             const GeometricField<Type, fvPatchField, volMesh>&
 146         );
 147
 148         //- Sample and write all the fields of the given type
 149         template<class Type>
 150         void sampleAndWrite(const fieldGroup<Type>&);
 151
 152         //- Disallow default bitwise copy construct
 153         probes(const probes&);
 154
 155         //- Disallow default bitwise assignment
 156         void operator=(const probes&);
 157
 158
 159 public:
 160
 161     //- Runtime type information
 162     TypeName("probes");
 163
 164
 165     // Constructors
 166
 167         //- Construct for given objectRegistry and dictionary.
 168         //  Allow the possibility to load fields from files
 169         probes
 170         (
 171             const word& name,
 172             const objectRegistry&,
 173             const dictionary&,
 174             const bool loadFromFiles = false
 175         );
 176
 177
 178     //- Destructor
 179     virtual ~probes();
 180
 181
 182     // Member Functions
 183
 184         //- Return name of the set of probes
 185         virtual const word& name() const
 186         {
 187             return name_;
 188         }
 189
 190         //- Return names of fields to probe
 191         virtual const wordReList& fieldNames() const
 192         {
 193             return fieldSelection_;
 194         }
 195
 196         //- Return locations to probe
 197         virtual const pointField& probeLocations() const
 198         {
 199             return *this;
 200         }
 201
 202         //- Return location for probe i
 203         virtual const point& probe(const label i) const
 204         {
 205             return operator[](i);
 206         }
 207
 208         //- Cells to be probed (obtained from the locations)
 209         const labelList& elemets() const
 210         {
 211             return elementList_;
 212         }
 213
 214         //- Execute, currently does nothing
 215         virtual void execute();
 216
 217         //- Execute at the final time-loop, currently does nothing
 218         virtual void end();
 219
 220         //- Sample and write
 221         virtual void write();
 222
 223         //- Read the probes
 224         virtual void read(const dictionary&);
 225
 226         //- Update for changes of mesh
 227         virtual void updateMesh(const mapPolyMesh&)
 228         {}
 229
 230         //- Update for changes of mesh
 231         virtual void movePoints(const pointField&)
 232         {}
 233
 234         //- Update for changes of mesh due to readUpdate
 235         virtual void readUpdate(const polyMesh::readUpdateState state)
 236         {}
 237
 238         //- Sample a volume field at all locations
 239         template<class Type>
 240         tmp<Field<Type> > sample
 241         (
 242             const GeometricField<Type, fvPatchField, volMesh>&
 243         ) const;
 244
 245         //- Sample a single field on all sample locations
 246         template <class Type>
 247         tmp<Field<Type> > sample(const word& fieldName) const;
 248 };
 249
 250
 251 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 252
 253 } // End namespace Foam
 254
 255 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 256
 257 #ifdef NoRepository
 258 #   include "probesTemplates.C"
 259 #endif
 260
 261 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 262
 263 #endif
 264
 265 // ************************************************************************* //