Env.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2003 - 2010 Sandia Corporation.                       */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#ifndef STK_UTIL_DIAG_Env_h
#define STK_UTIL_DIAG_Env_h

#include <ios> // #include <iosfwd> // ios_base is not defined in the forward file
#include <string>

#include <stk_util/stk_config.h>
#if defined( STK_HAS_MPI )
#include <mpi.h>
#endif
#include <stk_util/parallel/Parallel.hpp>

#include <stk_util/environment/ProgramOptions.hpp>
#include <stk_util/util/Bootstrap.hpp>

#include <stk_util/util/FeatureTest.hpp>
#include <stk_util/diag/Option.hpp>
#include <stk_util/diag/Writer_fwd.hpp>

namespace sierra {

namespace Env {

static const std::string PARAM_ON = "on";  


enum ExecType {
  EXEC_TYPE_WORLD = 0,            
  EXEC_TYPE_FLUID = 1,            
  EXEC_TYPE_LAG   = 2,            
  EXEC_TYPE_PEER  = 3             
};

struct ExecInfo
{
  MPI_Comm              m_groupComm;
  int                   m_master;
};



 bool StartupSierra(int *argc, char ***argv, const char *product_name, const char *build_date_time,
             ExecType mpi_key = EXEC_TYPE_WORLD, const std::vector<int> *peer_sizes = NULL);

 //
 //  Cleanup any MPI stuff that was created from the startup sierra call, pass in the MPI initialization flag
 //  that StartupSierra generated
 //
 void ShutDownSierra(bool mpiInitFlag);

  
class Startup
{
public:

  Startup(int *argc, char ***argv, const char *product_name, const char *build_date_time,
    ExecType mpi_key = EXEC_TYPE_WORLD, const std::vector<int> *peer_sizes = NULL);

  ~Startup();

private:
  void startup(int *argc, char ***argv, const char *product_name, const char *build_time,
         ExecType mpi_key, const std::vector<int> *peer_sizes);
  
private:
  bool m_mpiInitFlag;     
};


void reset(MPI_Comm mpi_comm); // , const char * const work_dir = NULL);
void setMpiCommunicator(MPI_Comm communicator);
bool is_comm_valid();


const std::string &get_param(const char * const option);


void set_param(const char *option, const std::string &value);

const std::string &product_name();


bool developer_mode();

void set_input_file_required(bool value);

void setInputFileName(std::string value);
std::string getInputFileName();


void set_check_subcycle(bool value);

const std::string &architecture();


const std::string &executable_file();


const std::string &executable_date();

const std::string &startup_date();


double start_time();


double wall_now();


double cpu_now();


double vm_now();


const std::string working_directory();


std::ostream &output();


std::ostream &outputP0();


std::ostream &outputNull();


//std::ostream &output_open(const char * const filename);


const char *section_separator();


const char *subsection_separator();


std::string section_title(const std::string &title);


void output_flush();


void output_flush(std::ostream &stream);

void request_shutdown(bool shutdown = true);

bool is_shutdown_requested();

void abort();


MPI_Comm parallel_comm();

MPI_Comm parallel_world_comm();


int peer_group();


int parallel_fluid_master();


int parallel_lag_master();


int parallel_size();


int parallel_rank();

// /**
//  * @brief Function <b>set_current_diag_stream</b> set the diagnostic writer current out
//  * put stream.  The special names - and cout attach the diag stream to the std::cout
//  * stream.  The special name cerr attaches the stream to the std::cerr stream, output
//  * attaches to the stream Env::output() and outputp0 to the stream outputP0().  Otherwise,
//  * the file is opened with <b>mode</b> ios mode flags and attached to the diagnostic
//  * stream.
//  *
//  * @param path     a <b>char</b> const pointer to the file path to
//  *       open.
//  *
//  * @param mode     a <b>std::ios::openmode</b> value of the ios mode to
//  *       open the file.
//  *
//  */
// void set_current_diag_stream(const char *path, std::ios_base::openmode mode = std::ios_base::out);

// /**
//  * @brief Function <b>getCurrentStream</b> returns the current diagnostic stream.
//  *
//  * @return     a <b>std::ostream</b> reference to the current diagnostic
//  *       stream.
//  */
// // Diag::Stream &get_current_diag_stream();
// std::ostream &get_current_diag_stream();


} // namespace Env
} // namespace sierra

#endif // STK_UTIL_DIAG_Env_h