src/OpenFOAM/db/Time/findInstance.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 Description
  25     If "name" is empty: return the location of "directory"
  26     If "name" is not empty: return the location of "directory" containing the
  27     file "name".
  28     Used in reading mesh data.
  29
  30 \*---------------------------------------------------------------------------*/
  31
  32 #include "Time.H"
  33 #include "IOobject.H"
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 Foam::word Foam::Time::findInstance
  38 (
  39     const fileName& dir,
  40     const word& name,
  41     const IOobject::readOption rOpt,
  42     const word& stopInstance
  43 ) const
  44 {
  45     // Note: if name is empty, just check the directory itself
  46
  47
  48     const fileName tPath(path());
  49     const fileName dirPath(tPath/timeName()/dir);
  50
  51     // check the current time directory
  52     if
  53     (
  54         name.empty()
  55       ? isDir(dirPath)
  56       :
  57         (
  58             isFile(dirPath/name)
  59          && IOobject(name, timeName(), dir, *this).headerOk()
  60         )
  61     )
  62     {
  63         if (debug)
  64         {
  65             Info<< "Time::findInstance"
  66                 "(const fileName&, const word&"
  67                 ", const IOobject::readOption, const word&)"
  68                 << " : found \"" << name
  69                 << "\" in " << timeName()/dir
  70                 << endl;
  71         }
  72
  73         return timeName();
  74     }
  75
  76     // Search back through the time directories to find the time
  77     // closest to and lower than current time
  78
  79     instantList ts = times();
  80     label instanceI;
  81
  82     for (instanceI = ts.size()-1; instanceI >= 0; --instanceI)
  83     {
  84         if (ts[instanceI].value() <= timeOutputValue())
  85         {
  86             break;
  87         }
  88     }
  89
  90     // continue searching from here
  91     for (; instanceI >= 0; --instanceI)
  92     {
  93         if
  94         (
  95             name.empty()
  96           ? isDir(tPath/ts[instanceI].name()/dir)
  97           :
  98             (
  99                 isFile(tPath/ts[instanceI].name()/dir/name)
 100              && IOobject(name, ts[instanceI].name(), dir, *this).headerOk()
 101             )
 102         )
 103         {
 104             if (debug)
 105             {
 106                 Info<< "Time::findInstance"
 107                     "(const fileName&, const word&"
 108                     ", const IOobject::readOption, const word&)"
 109                     << " : found \"" << name
 110                     << "\" in " << ts[instanceI].name()/dir
 111                     << endl;
 112             }
 113
 114             return ts[instanceI].name();
 115         }
 116
 117         // Check if hit minimum instance
 118         if (ts[instanceI].name() == stopInstance)
 119         {
 120             if (debug)
 121             {
 122                 Info<< "Time::findInstance"
 123                     "(const fileName&, const word&"
 124                     ", const IOobject::readOption, const word&)"
 125                     << " : hit stopInstance " << stopInstance
 126                     << endl;
 127             }
 128
 129             if
 130             (
 131                 rOpt == IOobject::MUST_READ
 132              || rOpt == IOobject::MUST_READ_IF_MODIFIED
 133             )
 134             {
 135                 FatalErrorIn
 136                 (
 137                     "Time::findInstance"
 138                     "(const fileName&, const word&"
 139                     ", const IOobject::readOption, const word&)"
 140                 )   << "Cannot find file \"" << name << "\" in directory "
 141                     << dir << " in times " << timeName()
 142                     << " down to " << stopInstance
 143                     << exit(FatalError);
 144             }
 145
 146             return ts[instanceI].name();
 147         }
 148     }
 149
 150
 151     // not in any of the time directories, try constant
 152
 153     // Note. This needs to be a hard-coded constant, rather than the
 154     // constant function of the time, because the latter points to
 155     // the case constant directory in parallel cases
 156
 157     if
 158     (
 159         name.empty()
 160       ? isDir(tPath/constant()/dir)
 161       :
 162         (
 163             isFile(tPath/constant()/dir/name)
 164          && IOobject(name, constant(), dir, *this).headerOk()
 165         )
 166     )
 167     {
 168         if (debug)
 169         {
 170             Info<< "Time::findInstance"
 171                 "(const fileName&, const word&"
 172                 ", const IOobject::readOption, const word&)"
 173                 << " : found \"" << name
 174                 << "\" in " << constant()/dir
 175                 << endl;
 176         }
 177
 178         return constant();
 179     }
 180
 181     if (rOpt == IOobject::MUST_READ || rOpt == IOobject::MUST_READ_IF_MODIFIED)
 182     {
 183         FatalErrorIn
 184         (
 185             "Time::findInstance"
 186             "(const fileName&, const word&"
 187             ", const IOobject::readOption, const word&)"
 188         )   << "Cannot find file \"" << name << "\" in directory "
 189             << dir << " in times " << timeName()
 190             << " down to " << constant()
 191             << exit(FatalError);
 192     }
 193
 194     return constant();
 195 }
 196
 197
 198 // ************************************************************************* //