ExampleProgram.H

Go to the documentation of this file.

#ifndef __EXAMPLE_PROGRAM_H__
#define __EXAMPLE_PROGRAM_H__
#ifdef _GRIDCONVERSION_PARALLEL_
#include "COMM.H"
#endif
#include "Global.H"
#include "Profiler.H"

namespace GridConversion {
  
  namespace ExampleProgram {
    typedef IRAD::Profiler::ProfilerObj ProfilerType;
    typedef std::string                 StackType;
    typedef IRAD::Global::GlobalObj<StackType,int,ProfilerType> GlobalType;
#ifdef _GRIDCONVERSION_PARALLEL_
    typedef IRAD::Comm::CommunicatorObject CommType;
    typedef IRAD::Global::ParallelGlobalObj<CommType,StackType,int,ProfilerType> PGlobalType;
#endif
    class ExampleProgramComLine : public IRAD::Util::ComLineObject
    {
    public:
      ExampleProgramComLine()
        : IRAD::Util::ComLineObject()
      {};
      ExampleProgramComLine(const char *args[])
        : IRAD::Util::ComLineObject(args)
      {};
      void Initialize(){
        AddOption('h',"help");
        AddOption('v',"verbosity",1);
        AddOption('o',"output",2,"filename");
        AddArgument("input",1);
        AddHelp("help","Prints this long version of help.");
        AddHelp("output","Specifies the name of the output file.");
        std::ostringstream Ostr;
        Ostr << "Mode-dependent input: Input <filename> for serial example"
             << "\n\t\tprogram, or <number of divisions> for parallel example.";
        AddArgHelp("input",Ostr.str());
        // The following commented string formation is kept around to 
        // illustrate the required tabs and newlines to make the output 
        // look proper:
        //
        //    Ostr << "Use fixed problem size in scalability analysis.  Only makes"
        //         << "\n\t\tsense when scalability mode is enabled.";
        //    Ostr.str("");
        Ostr.str("");
        Ostr << "Example GridConversion program.";
        _description.assign(Ostr.str());
      };
    };
    
    typedef ExampleProgramComLine ComLineType;
    typedef IRAD::Global::Program<GlobalType,ComLineType> SerialProgramType;
#ifdef _GRIDCONVERSION_PARALLEL_
    typedef IRAD::Global::Program<PGlobalType,ComLineType> ParallelProgramType;
#endif
    class SerialProgram : public SerialProgramType
    {
    protected:
      std::string output_name;
      std::string input_name;
      int verblevel;
      std::ofstream Ouf;
      std::ifstream Inf;
    public:
      SerialProgram() :
        SerialProgramType()
      {};
      SerialProgram(int nargs,char **args) :
        SerialProgramType(nargs,args)
      {};
      virtual int Initialize()
      {
        int retval = SerialProgramType::Initialize();
        if(!_command_line.GetOption("help").empty()){
          std::ostringstream Ostr;
          Ostr << _command_line.LongUsage() << std::endl;
          StdOut(Ostr.str());
          return(-1);
        }
        if(retval){
          std::ostringstream Ostr;
          Ostr << _command_line.ErrorReport() << std::endl
               << std::endl << _command_line.ShortUsage() << std::endl;
          ErrOut(Ostr.str());
          return(retval);
        }

        // Check if output file is specified
        output_name = _command_line.GetOption("output");

        // Set input file to first argument
        std::vector<std::string> args(_command_line.GetArgs());
        input_name = args[0];

        // Check the verbosity level
        std::string sverb(_command_line.GetOption("verbosity"));
        if(sverb.empty() || sverb == ".true.")
          verblevel = 1;
        else {
          std::istringstream Vin(sverb);
          Vin >> verblevel;
          if(verblevel < 0)
            verblevel = 1;
        }

        // If high verbosity, stick a configuration blurb to stdout.
        if(verblevel > 1){
          std::ostringstream Ostr;
          Ostr << "Configuration:" << std::endl
               << "verbosity           = " << verblevel << std::endl
               << "input_name          = " << input_name << std::endl;
          if(!output_name.empty())
            Ostr << "output file         = " << output_name << std::endl;
          Ostr << std::endl;
          StdOut(Ostr.str());
        } 

        return(0);
      };
      int VerbLevel() const { return verblevel;};
      virtual ~SerialProgram() {
        if(Ouf){
          Ouf.close();
          SetOutStream(std::cout);
        }
      };
      virtual int Run();
    };
    

#ifdef _GRIDCONVERSION_PARALLEL_
    class ParallelProgram : public ParallelProgramType
    {
    protected:
      std::string output_name;
      int verblevel;           
      std::ofstream Ouf;      
      int ndiv;
    public:
      ParallelProgram() :
        ParallelProgramType()
      {verblevel = 0;};
      ParallelProgram(int nargs,char **args) :
        ParallelProgramType(nargs,args)
      {verblevel = 0;};
      ParallelProgram(ComLineType &comline,CommType &incomm) 
      {
        this->_command_line.Copy(comline);
        this->Init(_command_line.ProgramName(),incomm);
        verblevel = 0;
      };
      virtual int Initialize()
      {
        int retval = ParallelProgramType::Initialize();
        // Check if the user just entered -h or --help
        if(!_command_line.GetOption("help").empty()){
          std::ostringstream Ostr;
          Ostr << _command_line.LongUsage() << std::endl;
          StdOut(Ostr.str());
          return(-1);
        }
        if(retval){ // then there were errors on the command line
          std::ostringstream Ostr;
          Ostr << _command_line.ErrorReport() << std::endl
               << std::endl << _command_line.ShortUsage() << std::endl;
          ErrOut(Ostr.str());
          return(retval);
        }

        // Everything is OK up to here, so check for an output file.
        output_name = _command_line.GetOption("output");

        // Set number of divisions to first argument
        std::vector<std::string> args(_command_line.GetArgs());
        std::istringstream Istr(args[0]);
        Istr >> ndiv;

        // Check the verbosity level
        std::string sverb(_command_line.GetOption("verbosity"));
        if(sverb.empty() || sverb == ".true.")
          verblevel = 1;
        else {
          std::istringstream Vin(sverb);
          Vin >> verblevel;
          if(verblevel < 0)
            verblevel = 1;
        }

        // If high verbosity, stick a configuration blurb to stdout.
        if(verblevel > 1){
          std::ostringstream Ostr;
          Ostr << "Configuration:" << std::endl
               << "verbosity           = " << verblevel << std::endl
               << "number of divisions = " << ndiv << std::endl;
          if(!output_name.empty())
            Ostr << "output file         = " << output_name << std::endl;
          Ostr << std::endl;
          StdOut(Ostr.str());
        } 

        return(0);
      };
      int VerbLevel() const { return verblevel;};
      virtual ~ParallelProgram() {
        if(Ouf){
          Ouf.close();
          SetOutStream(std::cout);
        }
      };
      virtual int Run();
    };
#endif    


    template<typename ProgramType>
    int Driver(int argc,char *argv[])
    {
      ProgramType MyProgram(argc,argv);
      int retval = MyProgram.Initialize();
      if(retval){
        if(retval > 0){ // then there was an error
          MyProgram.ErrOut("Error in Program Initialization.\n");
          return(1);
        }
        else return(0); // no error, but the program should not continue
      }
      if(MyProgram.VerbLevel() > 1)
        MyProgram.StdOut("Calling RUN.\n");
      if(MyProgram.Run()){
        MyProgram.ErrOut("Error in Program RUN method.\n");
        return(1);
      }
      if(MyProgram.VerbLevel() > 1){
        std::ostringstream Ostr;
        MyProgram.Report(Ostr);
        MyProgram.StdOut(Ostr.str());
        MyProgram.StdOut("Calling Finalize.\n");
      }
      if(MyProgram.Finalize()){
        MyProgram.ErrOut("Error in Program Finalization.\n");
        return(1);
      }
      if(MyProgram.VerbLevel() > 1)
        MyProgram.StdOut("All done.\n");
      return(0);
    }


    typedef GridConversion::ExampleProgram::SerialProgram SEProgramType;
#ifdef _GRIDCONVERSION_PARALLEL_
    inline double f(double x)
    {
      return (4.0 / (1.0 + x*x));
    }
    typedef GridConversion::ExampleProgram::ParallelProgram PEProgramType;
#endif
  };
};
#endif