DriverProgram.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"
#include "Mesh.H"

namespace GridConversion {
  
  namespace DriverProgram {
    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 DriverProgramComLine : public IRAD::Util::ComLineObject
    {
    public:
      DriverProgramComLine()
        : IRAD::Util::ComLineObject()
      {};
      DriverProgramComLine(const char *args[])
        : IRAD::Util::ComLineObject(args)
      {};
      void Initialize(){
        AddOption('h',"help");
        //AddOption('q',"quadratic");
        AddOption('v',"verbosity",1);
        AddOption('o',"output",2,"filename");
        AddArgument("grid input> <bc input",1);
        AddHelp("help","Prints this long version of help.");
        AddHelp("output","Specifies the name of the output file.");
        std::ostringstream Ostr;
        //Ostr << "If using a mesh with tetrahedral elements, specifying" << std::endl
        //     << "this flag will cause the application to change the 4 node" << std::endl
        //     << " tetrahedra from input to 10 node quadratic tetrahedra";
        //AddHelp("quadratic",Ostr.str());
        Ostr.str("");
        Ostr << "GridConversion requires two arguments in order:" << std::endl
             << "                "
             << "su2 grid file> <bc file> where the su2 is a grid" << std::endl
             << "                 "
             << "analysis file output from Pointwise in Stanford format." << std::endl
             << "                "
             << "The bc file indicates a Rocfrac boundary condition for "
             << "each" << std::endl
             << "                domain." << std::endl
             << "                See the Grid Conversion User Manual for more "
             << "information on" << std::endl
             << "                the formats of these two files" << std::endl;
        AddArgHelp("grid input> <bc 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 << "Main GridConversion program.";
        _description.assign(Ostr.str());

      };
    };
    
    typedef DriverProgramComLine 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;
      std::string bc_input_name;
      int verblevel;
      std::ofstream Ouf;
      std::ifstream Inf;
      bool quadratic;
      int numNodes;
      std::vector<double> nodes;
      // vector of vectors to hold nodal bc flags
      std::vector< std::vector<int> > nodeBCs;
      std::vector< std::vector< std::vector<double> > > nodeBCValues;
      // vector to hold the list of nodes to domains
      SolverUtils::Mesh::Connectivity nodesToDomains;
      int numElemEdges;
      std::vector<unsigned int> elemEdges;
      int numNodesPerElemEdge;
      std::vector<unsigned int> elemToElemEdges;
      //number of edges per element
      int numEdgesPerElem;
      int numElems;
      std::vector< std::vector<unsigned int> > nodeToNode;
      std::vector<unsigned int> elems;
      std::vector< std::vector<int> > elemBCs;
      std::vector< std::vector< std::vector<double> > > elemBCValues;
      int numNodesPerElem;
      std::vector< std::vector<int> >elemsToDomains;
      int elemShape;
      std::vector<std::string> shapes;
      int numDomains;
      std::vector< std::vector<unsigned int> > domains;
      std::vector< std::vector<int> > domainBCs;
      std::vector< std::vector< std::vector<double> > > domainBCValues;
      std::vector< std::vector<int> > edges;
      std::vector< std::vector<int> > edgeBCs;
      std::vector< std::vector< std::vector<double> > > edgeBCValues;
    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);
        }

        //Initialize mesh values to 0
        numNodes = 0;
        numElems = 0;
        numDomains = 0;
        numNodesPerElem = 0;
        elemShape = 0;

        //Set element shape vector (shape numbers are those used in Patran grid files)
        shapes.resize(10);
        shapes[0] = shapes[1] = shapes[6] = "none";
        shapes[2]= "bar";
        shapes[3] = "triangle";
        shapes[4] = "quadrilateral";
        shapes[5] = "tetrahedron";
        shapes[7] = "triangular prism";
        shapes[8] = "hexahedron";
        shapes[9] = "pyramid";

        // Check if we should create higher order elements
        quadratic = false;
        if(!_command_line.GetOption("quadratic").empty())
          quadratic = true;        

        // 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];
        bc_input_name = args[1];

        // 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
               << "bc_input_name       = " << bc_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();
      virtual int ReadPatranInput();
      virtual int ReadStanfordInput();
      virtual int HigherOrderTets(SolverUtils::Mesh::Connectivity elemEdgeToElems,
                                  SolverUtils::Mesh::Connectivity nodesToDomains);
      virtual int ConnectivityMaps(SolverUtils::Mesh::Connectivity nodesToElems);
      virtual int WriteOutput();
    };
    

#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::DriverProgram::SerialProgram SEProgramType;
#ifdef _GRIDCONVERSION_PARALLEL_
    inline double f(double x)
    {
      return (4.0 / (1.0 + x*x));
    }
    typedef GridConversion::DriverProgram::ParallelProgram PEProgramType;
#endif
  };
};
#endif