src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "PatchPostProcessing.H"
  28 #include "Pstream.H"
  29 #include "ListListOps.H"
  30
  31 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  32
  33 template <class CloudType>
  34 Foam::label Foam::PatchPostProcessing<CloudType>::applyToPatch
  35 (
  36     const label globalPatchI
  37 ) const
  38 {
  39     forAll(patchIds_, patchI)
  40     {
  41         if (patchIds_[patchI] == globalPatchI)
  42         {
  43             return patchI;
  44         }
  45     }
  46
  47     return -1;
  48 }
  49
  50
  51 // * * * * * * * * * * * * * protected Member Functions  * * * * * * * * * * //
  52
  53 template<class CloudType>
  54 void Foam::PatchPostProcessing<CloudType>::write()
  55 {
  56     forAll(patchData_, patchI)
  57     {
  58         List<List<string> > procData(Pstream::nProcs());
  59         procData[Pstream::myProcNo()] = patchData_[patchI];
  60
  61         Pstream::gatherList(procData);
  62
  63         if (Pstream::master())
  64         {
  65             fileName outputDir;
  66
  67             if (Pstream::parRun())
  68             {
  69                 // Put in undecomposed case (Note: gives problems for
  70                 // distributed data running)
  71                 outputDir =
  72                     mesh_.time().path()/".."/"postProcessing"/cloud::prefix/
  73                     this->owner().name()/this->owner().time().timeName();
  74             }
  75             else
  76             {
  77                 outputDir =
  78                     mesh_.time().path()/"postProcessing"/cloud::prefix/
  79                     this->owner().name()/this->owner().time().timeName();
  80             }
  81
  82             // Create directory if it doesn't exist
  83             mkDir(outputDir);
  84
  85             OFstream patchOutFile
  86             (
  87                 outputDir/patchNames_[patchI] + ".post",
  88                 ios_base::out|ios_base::trunc,
  89                 IOstream::ASCII,
  90                 IOstream::currentVersion,
  91                 mesh_.time().writeCompression()
  92             );
  93
  94             List<string> globalData;
  95             globalData = ListListOps::combine<List<string> >
  96             (
  97                 procData,
  98                 accessOp<List<string> >()
  99             );
 100             sort(globalData);
 101
 102             patchOutFile<< "# Time " + parcelType::propHeader << nl;
 103
 104             forAll(globalData, i)
 105             {
 106                 patchOutFile<< globalData[i].c_str() << nl;
 107             }
 108         }
 109
 110         patchData_[patchI].clearStorage();
 111     }
 112 }
 113
 114
 115 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 116
 117 template<class CloudType>
 118 Foam::PatchPostProcessing<CloudType>::PatchPostProcessing
 119 (
 120     const dictionary& dict,
 121     CloudType& owner
 122 )
 123 :
 124     PostProcessingModel<CloudType>(dict, owner, typeName),
 125     mesh_(owner.mesh()),
 126     maxStoredParcels_(readLabel(this->coeffDict().lookup("maxStoredParcels"))),
 127     patchNames_(this->coeffDict().lookup("patches")),
 128     patchData_(patchNames_.size()),
 129     patchIds_(patchNames_.size())
 130 {
 131     forAll(patchNames_, patchI)
 132     {
 133         label id = mesh_.boundaryMesh().findPatchID(patchNames_[patchI]);
 134         if (id < 0)
 135         {
 136             FatalErrorIn
 137             (
 138                 "PatchPostProcessing<CloudType>::PatchPostProcessing"
 139                 "("
 140                     "const dictionary&, "
 141                     "CloudType& owner"
 142                 ")"
 143             )<< "Requested patch " << patchNames_[patchI] << " not found" << nl
 144              << "Available patches are: " << mesh_.boundaryMesh().names() << nl
 145              << exit(FatalError);
 146         }
 147         patchIds_[patchI] = id;
 148     }
 149 }
 150
 151
 152 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 153
 154 template<class CloudType>
 155 Foam::PatchPostProcessing<CloudType>::~PatchPostProcessing()
 156 {}
 157
 158
 159 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 160
 161 template<class CloudType>
 162 bool Foam::PatchPostProcessing<CloudType>::active() const
 163 {
 164     return true;
 165 }
 166
 167
 168 template<class CloudType>
 169 void Foam::PatchPostProcessing<CloudType>::postPatch
 170 (
 171     const parcelType& p,
 172     const label patchI
 173 )
 174 {
 175     label localPatchI = applyToPatch(patchI);
 176     if (localPatchI >= 0 && patchData_[localPatchI].size() < maxStoredParcels_)
 177     {
 178         OStringStream data;
 179         data<< this->owner().time().timeName() << ' ' << p;
 180         patchData_[localPatchI].append(data.str());
 181     }
 182 }
 183
 184
 185 // ************************************************************************* //