sOutputManager.hh

Go to the documentation of this file.

/*
This file is part of CASToR.

    CASToR is free software: you can redistribute it and/or modify it under the
    terms of the GNU General Public License as published by the Free Software
    Foundation, either version 3 of the License, or (at your option) any later
    version.

    CASToR is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    details.

    You should have received a copy of the GNU General Public License along with
    CASToR (in file GNU_GPL.TXT). If not, see <http://www.gnu.org/licenses/>.

Copyright 2017-2018 all CASToR contributors listed below:

    --> current contributors: Thibaut MERLIN, Simon STUTE, Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Mael MILLARDET
    --> past contributors: Valentin VIELZEUF

This is CASToR version 2.0.
*/

#ifndef SOUTPUTMANAGER_HH
#define SOUTPUTMANAGER_HH 1

#include "gVariables.hh"
class oImageDimensionsAndQuantification;

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

// Cross-platform directory separator, if required
// Windows might auto-convert '/' to '\' though
#ifdef _WIN32
#define OS_SEP "\\"
#else
#define OS_SEP "/"
#endif

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

// Use to convert a macro variable provided by the pre-processor, to a string
#define QUOTES(value) #value
#define TOSTRING(macro) QUOTES(macro)
// The CASTOR_CONFIG environment variable converted to a string
#ifdef CASTOR_CONFIG
#define CASTOR_CONFIG_STRING TOSTRING(CASTOR_CONFIG)
#endif

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

#ifdef CASTOR_MPI
// Macros for logging messages on standard output (with MPI)
#define Cout(MESSAGE)                                           \
  do                                                            \
  {                                                             \
    int mpi_rank; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);     \
    if (mpi_rank==0)                                            \
    {                                                           \
      std::cout << MESSAGE;                                     \
      sOutputManager* instance = sOutputManager::GetInstance(); \
      if (instance!=NULL)                                       \
      {                                                         \
        ofstream& logMac = instance->GetLogFile();              \
        if (logMac) logMac << MESSAGE;                          \
      }                                                         \
    }                                                           \
  } while(0)
// Macros for logging messages on standard error (with MPI)
#define Cerr(MESSAGE)                                           \
  do                                                            \
  {                                                             \
    int mpi_rank; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);     \
    std::cerr << "***** The following error message was issued" \
              << " by MPI instance " << mpi_rank << endl;       \
    std::cerr << MESSAGE;                                       \
    sOutputManager* instance = sOutputManager::GetInstance();   \
    if (instance!=NULL)                                         \
    {                                                           \
      ofstream& logMac = instance->GetLogFile();                \
      if (logMac)                                               \
      {                                                         \
        logMac << "***** The following error message was issued"\
               << " by MPI instance " << mpi_rank << endl;      \
        logMac << MESSAGE;                                      \
      }                                                         \
    }                                                           \
  } while(0)
#else
// Macros for logging messages on standard output (without MPI)
#define Cout(MESSAGE)                                         \
  do                                                          \
  {                                                           \
    std::cout << MESSAGE;                                     \
    sOutputManager* instance = sOutputManager::GetInstance(); \
    if (instance!=NULL)                                       \
    {                                                         \
      ofstream& logMac = instance->GetLogFile();              \
      if (logMac) logMac << MESSAGE;                          \
    }                                                         \
  } while(0)
// Macros for logging messages on standard error (without MPI)
#define Cerr(MESSAGE)                                         \
  do                                                          \
  {                                                           \
    std::cerr << MESSAGE;                                     \
    sOutputManager* instance = sOutputManager::GetInstance(); \
    if (instance!=NULL)                                       \
    {                                                         \
      ofstream& logMac = instance->GetLogFile();              \
      if (logMac) logMac << MESSAGE;                          \
    }                                                         \
  } while(0)
#endif

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

// Verbose levels definitions
#define VERBOSE_LIGHT  1
#define VERBOSE_NORMAL 2
#define VERBOSE_DETAIL 3
#define VERBOSE_DEBUG_LIGHT  4
#define VERBOSE_DEBUG_NORMAL 5
#define VERBOSE_DEBUG_EVENT  6
#define VERBOSE_DEBUG_MAX    7

// Macro for CASTOR_VERBOSE to print out the entering of each function.
// This may be used for debugging. When this compilation variable is not
// set, this does nothing.

// If CASTOR_VERBOSE is not set, we define this macro as doing nothing ';'
#ifndef CASTOR_VERBOSE

  #define DEBUG_VERBOSE(IGNORED1,IGNORED2) ;

// If CASTOR_VERBOSE is set, we differentiate between windows/unix systems
#else
  // Case for pure windows
  #if defined(_WIN32) && !defined(CASTOR_USE_MINGW)
    #define DEBUG_VERBOSE(CURRENT_LEVEL,APPLICABLE_LEVEL)  \
      do                                                   \
      {                                                    \
        if (CURRENT_LEVEL >= APPLICABLE_LEVEL)             \
        {                                                  \
          cout << "+++++ " << __FUNCSIG__                  \
               << " -> Entering this function" << endl;    \
        }                                                  \
      } while(0);
  // Case for unix and cross-compilation from unix to windows
  #else
    #define DEBUG_VERBOSE(CURRENT_LEVEL,APPLICABLE_LEVEL)  \
      do                                                   \
      {                                                    \
        if (CURRENT_LEVEL >= APPLICABLE_LEVEL)             \
        {                                                  \
          cout << "+++++ " << __PRETTY_FUNCTION__          \
               << " -> Entering this function" << endl;    \
        }                                                  \
      } while(0);
  #endif
#endif

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

// Function used to make an clean exit taking MPI finalize into account
void Exit(int code);

// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

class sOutputManager
{
  // -------------------------------------------------------------------
  // Constructor & Destructor
  public:
    static sOutputManager* GetInstance() 
    { 
      if (mp_Instance == NULL) mp_Instance = new sOutputManager();
      return mp_Instance;
    }


  // -------------------------------------------------------------------
  // Get & Set functions
  public:
    inline void SetVerbose( int a_verbose )
           {m_verbose = a_verbose;}
    inline void SetDataFileName( vector<string> ap_dataFileName )
           {mp_dataFileName = ap_dataFileName;}
    inline ofstream& GetLogFile()
           {return m_logFile;}
    inline const string& GetBaseName()
           {return m_baseName;}
    inline const string& GetPathName()
           {return m_pathName;}
    inline vector<string> GetDataFileName()
           {return mp_dataFileName;}
    inline void SetMPIRank( int a_mpiRank )
           {m_mpiRank = a_mpiRank;}
    inline void SetMergeDynImagesFlag( bool a_flag )
           {m_mergeOutputDynImgFlag = a_flag;}
    inline bool MergeDynImages()
           {return m_mergeOutputDynImgFlag;}


    int SetOutNbPrec(string a_format);


  // -------------------------------------------------------------------
  // Public member functions
  public:
    int CheckConfigDir( const string& a_path );
    const string& GetPathToConfigDir();
    int InitOutputDirectory( const string& a_pathFout, const string& a_pathDout );
    int LogCommandLine( int argc, char** argv );
    
    
  // -------------------------------------------------------------------
  // Private member functions
  private:
    sOutputManager();
    ~sOutputManager();
    // Prevent the compiler to generate methods to copy the object
    sOutputManager(sOutputManager const&){};     
    void operator=(sOutputManager const&){};


  // -------------------------------------------------------------------
  // Data members
  private:
    static sOutputManager* mp_Instance; 
    int m_verbose;                      
    int m_mpiRank;                      
    string m_baseName;                  
    string m_pathName;                  
    string m_pathToConfigDir;           
    vector<string> mp_dataFileName;     
    ofstream m_logFile;                 
    bool m_mergeOutputDynImgFlag;       
};

#endif