src/lagrangian/basic/Cloud/CloudIO.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 "Cloud.H"
  27 #include "Time.H"
  28 #include "IOPosition.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 template<class ParticleType>
  33 Foam::word Foam::Cloud<ParticleType>::cloudPropertiesName("cloudProperties");
  34
  35
  36 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
  37
  38 template<class ParticleType>
  39 void Foam::Cloud<ParticleType>::readCloudUniformProperties()
  40 {
  41     IOobject dictObj
  42     (
  43         cloudPropertiesName,
  44         time().timeName(),
  45         "uniform"/cloud::prefix/name(),
  46         db(),
  47         IOobject::MUST_READ_IF_MODIFIED,
  48         IOobject::NO_WRITE,
  49         false
  50     );
  51
  52     if (dictObj.headerOk())
  53     {
  54         const IOdictionary uniformPropsDict(dictObj);
  55
  56         const word procName("processor" + Foam::name(Pstream::myProcNo()));
  57         if (uniformPropsDict.found(procName))
  58         {
  59             uniformPropsDict.subDict(procName).lookup("particleCount")
  60                 >> ParticleType::particleCount_;
  61         }
  62     }
  63     else
  64     {
  65         ParticleType::particleCount_ = 0;
  66     }
  67 }
  68
  69
  70 template<class ParticleType>
  71 void Foam::Cloud<ParticleType>::writeCloudUniformProperties() const
  72 {
  73     IOdictionary uniformPropsDict
  74     (
  75         IOobject
  76         (
  77             cloudPropertiesName,
  78             time().timeName(),
  79             "uniform"/cloud::prefix/name(),
  80             db(),
  81             IOobject::NO_READ,
  82             IOobject::NO_WRITE,
  83             false
  84         )
  85     );
  86
  87     labelList np(Pstream::nProcs(), 0);
  88     np[Pstream::myProcNo()] = ParticleType::particleCount_;
  89
  90     Pstream::listCombineGather(np, maxEqOp<label>());
  91     Pstream::listCombineScatter(np);
  92
  93     forAll(np, i)
  94     {
  95         word procName("processor" + Foam::name(i));
  96         uniformPropsDict.add(procName, dictionary());
  97         uniformPropsDict.subDict(procName).add("particleCount", np[i]);
  98     }
  99
 100     uniformPropsDict.writeObject
 101     (
 102         IOstream::ASCII,
 103         IOstream::currentVersion,
 104         time().writeCompression()
 105     );
 106 }
 107
 108
 109 template<class ParticleType>
 110 void Foam::Cloud<ParticleType>::initCloud(const bool checkClass)
 111 {
 112     readCloudUniformProperties();
 113
 114     IOPosition<Cloud<ParticleType> > ioP(*this);
 115
 116     if (ioP.headerOk())
 117     {
 118         ioP.readData(*this, checkClass);
 119         ioP.close();
 120
 121         if (this->size())
 122         {
 123             readFields();
 124         }
 125     }
 126     else
 127     {
 128         if (debug)
 129         {
 130             Pout<< "Cannot read particle positions file:" << nl
 131                 << "    " << ioP.objectPath() << nl
 132                 << "Assuming the initial cloud contains 0 particles." << endl;
 133         }
 134     }
 135
 136     // Ask for the tetBasePtIs to trigger all processors to build
 137     // them, otherwise, if some processors have no particles then
 138     // there is a comms mismatch.
 139     polyMesh_.tetBasePtIs();
 140
 141     forAllIter(typename Cloud<ParticleType>, *this, pIter)
 142     {
 143         ParticleType& p = pIter();
 144
 145         p.initCellFacePt();
 146     }
 147 }
 148
 149
 150 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 151
 152 template<class ParticleType>
 153 Foam::Cloud<ParticleType>::Cloud
 154 (
 155     const polyMesh& pMesh,
 156     const bool checkClass
 157 )
 158 :
 159     cloud(pMesh),
 160     polyMesh_(pMesh),
 161     labels_(),
 162     nTrackingRescues_(),
 163     cellWallFacesPtr_()
 164 {
 165     initCloud(checkClass);
 166 }
 167
 168
 169 template<class ParticleType>
 170 Foam::Cloud<ParticleType>::Cloud
 171 (
 172     const polyMesh& pMesh,
 173     const word& cloudName,
 174     const bool checkClass
 175 )
 176 :
 177     cloud(pMesh, cloudName),
 178     polyMesh_(pMesh),
 179     labels_(),
 180     nTrackingRescues_(),
 181     cellWallFacesPtr_()
 182 {
 183     initCloud(checkClass);
 184 }
 185
 186
 187 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 188
 189 template<class ParticleType>
 190 Foam::IOobject Foam::Cloud<ParticleType>::fieldIOobject
 191 (
 192     const word& fieldName,
 193     const IOobject::readOption r
 194 ) const
 195 {
 196     return IOobject
 197     (
 198         fieldName,
 199         time().timeName(),
 200         *this,
 201         r,
 202         IOobject::NO_WRITE,
 203         false
 204     );
 205 }
 206
 207
 208 template<class ParticleType>
 209 template<class DataType>
 210 void Foam::Cloud<ParticleType>::checkFieldIOobject
 211 (
 212     const Cloud<ParticleType>& c,
 213     const IOField<DataType>& data
 214 ) const
 215 {
 216     if (data.size() != c.size())
 217     {
 218         FatalErrorIn
 219         (
 220             "void Cloud<ParticleType>::checkFieldIOobject"
 221             "(const Cloud<ParticleType>&, const IOField<DataType>&) const"
 222         )   << "Size of " << data.name()
 223             << " field " << data.size()
 224             << " does not match the number of particles " << c.size()
 225             << abort(FatalError);
 226     }
 227 }
 228
 229
 230 template<class ParticleType>
 231 template<class DataType>
 232 void Foam::Cloud<ParticleType>::checkFieldFieldIOobject
 233 (
 234     const Cloud<ParticleType>& c,
 235     const CompactIOField<Field<DataType>, DataType>& data
 236 ) const
 237 {
 238     if (data.size() != c.size())
 239     {
 240         FatalErrorIn
 241         (
 242             "void Cloud<ParticleType>::checkFieldFieldIOobject"
 243             "("
 244                 "const Cloud<ParticleType>&, "
 245                 "const CompactIOField<Field<DataType>, DataType>&"
 246             ") const"
 247         )   << "Size of " << data.name()
 248             << " field " << data.size()
 249             << " does not match the number of particles " << c.size()
 250             << abort(FatalError);
 251     }
 252 }
 253
 254
 255 template<class ParticleType>
 256 void Foam::Cloud<ParticleType>::readFields()
 257 {}
 258
 259
 260 template<class ParticleType>
 261 void Foam::Cloud<ParticleType>::writeFields() const
 262 {
 263     if (this->size())
 264     {
 265         ParticleType::writeFields(*this);
 266     }
 267 }
 268
 269
 270 template<class ParticleType>
 271 bool Foam::Cloud<ParticleType>::writeObject
 272 (
 273     IOstream::streamFormat fmt,
 274     IOstream::versionNumber ver,
 275     IOstream::compressionType cmp
 276 ) const
 277 {
 278     writeCloudUniformProperties();
 279
 280     if (this->size())
 281     {
 282         writeFields();
 283         return cloud::writeObject(fmt, ver, cmp);
 284     }
 285     else
 286     {
 287         return true;
 288     }
 289 }
 290
 291
 292 // * * * * * * * * * * * * * * * Ostream Operators * * * * * * * * * * * * * //
 293
 294 template<class ParticleType>
 295 Foam::Ostream& Foam::operator<<(Ostream& os, const Cloud<ParticleType>& pc)
 296 {
 297     pc.writeData(os);
 298
 299     // Check state of Ostream
 300     os.check("Ostream& operator<<(Ostream&, const Cloud<ParticleType>&)");
 301
 302     return os;
 303 }
 304
 305
 306 // ************************************************************************* //