src/finiteVolume/cfdTools/general/fieldSources/timeActivatedExplicitMulticomponentPointSource/timeActivatedExplicitMulticomponentPointSource.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 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 "timeActivatedExplicitMulticomponentPointSource.H"
  28 #include "volFields.H"
  29
  30 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  31
  32 Foam::label
  33 Foam::timeActivatedExplicitMulticomponentPointSource::carrierFieldId
  34 (
  35     const word& fieldName
  36 )
  37 {
  38     forAll(carrierFields_, fieldI)
  39     {
  40         if (carrierFields_[fieldI].name() == fieldName)
  41         {
  42             return fieldI;
  43         }
  44     }
  45
  46     return -1;
  47 }
  48
  49
  50 void Foam::timeActivatedExplicitMulticomponentPointSource::updateAddressing()
  51 {
  52     forAll(pointSources_, sourceI)
  53     {
  54         const pointSourceProperties& psp = pointSources_[sourceI];
  55         bool foundCell = false;
  56         label cid = mesh_.findCell(psp.location());
  57         if (cid >= 0)
  58         {
  59             foundCell = mesh_.pointInCell(psp.location(), cid);
  60         }
  61         reduce(foundCell, orOp<bool>());
  62         if (!foundCell)
  63         {
  64             label cid = mesh_.findNearestCell(psp.location());
  65             if (cid >= 0)
  66             {
  67                 foundCell = mesh_.pointInCell(psp.location(), cid);
  68             }
  69         }
  70         reduce(foundCell, orOp<bool>());
  71
  72         if (!foundCell)
  73         {
  74             FatalErrorIn
  75             (
  76                 "timeActivatedExplicitMulticomponentPointSource::"
  77                 "updateAddressing()"
  78             )   << "Unable to find location " << psp.location() << " in mesh "
  79                 << "for source " << psp.name() << nl
  80                 << exit(FatalError);
  81         }
  82         else
  83         {
  84             cellOwners_[sourceI] = cid;
  85         }
  86
  87         fieldIds_[sourceI].setSize(psp.fieldData().size());
  88         forAll(psp.fieldData(), fieldI)
  89         {
  90             const word& fieldName = psp.fieldData()[fieldI].first();
  91             label cfid = carrierFieldId(fieldName);
  92             if (cfid < 0)
  93             {
  94                 FatalErrorIn
  95                 (
  96                     "timeActivatedExplicitMulticomponentPointSource::"
  97                     "updateAddressing()"
  98                 )   << "Unable to find field " << fieldName << " in carrier "
  99                     << "fields for source " << psp.name() << nl
 100                     << exit(FatalError);
 101             }
 102             else
 103             {
 104                 fieldIds_[sourceI][fieldI] = cfid;
 105             }
 106        }
 107     }
 108 }
 109
 110
 111 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 112
 113 Foam::timeActivatedExplicitMulticomponentPointSource::
 114 timeActivatedExplicitMulticomponentPointSource
 115 (
 116     const word& name,
 117     const fvMesh& mesh,
 118     const PtrList<volScalarField>& carrierFields,
 119     const dimensionSet& dims
 120 )
 121 :
 122     IOdictionary
 123     (
 124         IOobject
 125         (
 126             name + "Properties",
 127             mesh.time().constant(),
 128             mesh,
 129             IOobject::MUST_READ,
 130             IOobject::NO_WRITE
 131         )
 132     ),
 133     name_(name),
 134     mesh_(mesh),
 135     runTime_(mesh.time()),
 136     dimensions_(dims),
 137     carrierFields_(carrierFields),
 138     active_(lookup("active")),
 139     pointSources_(lookup("pointSources")),
 140     cellOwners_(pointSources_.size()),
 141     fieldIds_(pointSources_.size())
 142 {
 143     // Initialise the field addressing
 144     updateAddressing();
 145 }
 146
 147
 148 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 149
 150 Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh> >
 151 Foam::timeActivatedExplicitMulticomponentPointSource::Su
 152 (
 153     const label fieldI
 154 )
 155 {
 156     if (mesh_.changing())
 157     {
 158         updateAddressing();
 159     }
 160
 161     tmp<DimensionedField<scalar, volMesh> > tSource
 162     (
 163         new DimensionedField<scalar, volMesh>
 164         (
 165             IOobject
 166             (
 167                 name_ + carrierFields_[fieldI].name() + "Su",
 168                 runTime_.timeName(),
 169                 mesh_,
 170                 IOobject::NO_READ,
 171                 IOobject::NO_WRITE
 172             ),
 173             mesh_,
 174             dimensionedScalar("zero", dimensions_, 0.0)
 175         )
 176     );
 177
 178     if (active_)
 179     {
 180         DimensionedField<scalar, volMesh>& sourceField = tSource();
 181
 182         const scalarField& V = mesh_.V();
 183         const scalar dt = runTime_.deltaT().value();
 184
 185         forAll(pointSources_, sourceI)
 186         {
 187             const pointSourceProperties& psp = pointSources_[sourceI];
 188
 189             forAll(fieldIds_[sourceI], i)
 190             {
 191                 if
 192                 (
 193                     fieldIds_[sourceI][i] == fieldI
 194                 && (runTime_.time().value() >= psp.timeStart())
 195                 && (runTime_.time().value() <= psp.timeEnd())
 196                 )
 197                 {
 198                     const label cid = cellOwners_[sourceI];
 199                     if (cid >= 0)
 200                     {
 201                         sourceField[cid] +=
 202                             dt*psp.fieldData()[i].second()/V[cid];
 203                     }
 204                 }
 205             }
 206         }
 207     }
 208
 209     return tSource;
 210 }
 211
 212
 213 Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh> >
 214 Foam::timeActivatedExplicitMulticomponentPointSource::Su()
 215 {
 216     if (mesh_.changing())
 217     {
 218         updateAddressing();
 219     }
 220
 221     tmp<DimensionedField<scalar, volMesh> > tSource
 222     (
 223         new DimensionedField<scalar, volMesh>
 224         (
 225             IOobject
 226             (
 227                 name_ + "TotalSu",
 228                 runTime_.timeName(),
 229                 mesh_,
 230                 IOobject::NO_READ,
 231                 IOobject::NO_WRITE
 232             ),
 233             mesh_,
 234             dimensionedScalar("zero", dimensions_, 0.0)
 235         )
 236     );
 237
 238     if (active_)
 239     {
 240         DimensionedField<scalar, volMesh>& sourceField = tSource();
 241
 242         const scalarField& V = mesh_.V();
 243         const scalar dt = runTime_.deltaT().value();
 244
 245         forAll(pointSources_, sourceI)
 246         {
 247             const pointSourceProperties& psp = pointSources_[sourceI];
 248
 249             forAll(fieldIds_[sourceI], i)
 250             {
 251                 if
 252                 (
 253                    (runTime_.time().value() >= psp.timeStart())
 254                 && (runTime_.time().value() <= psp.timeEnd())
 255                 )
 256                 {
 257                     const label cid = cellOwners_[sourceI];
 258                     if (cid >= 0)
 259                     {
 260                         sourceField[cid] +=
 261                             dt*psp.fieldData()[i].second()/V[cid];
 262                     }
 263                 }
 264             }
 265         }
 266     }
 267
 268     return tSource;
 269 }
 270
 271
 272 bool Foam::timeActivatedExplicitMulticomponentPointSource::read()
 273 {
 274     if (regIOobject::read())
 275     {
 276         lookup("active") >> active_;
 277         lookup("pointSources") >> pointSources_;
 278
 279         cellOwners_.setSize(pointSources_.size());
 280
 281         updateAddressing();
 282
 283         return true;
 284     }
 285     else
 286     {
 287         return false;
 288     }
 289 }
 290
 291
 292 // ************************************************************************* //