PV_Init.hpp

/*
 * PV_Init.hpp
 *
 *  Created on: Jul 31, 2015
 *      Author: slundquist
 */

#ifndef PV_INIT_HPP_
#define PV_INIT_HPP_

#include <arch/mpi/mpi.h>
#include <columns/Arguments.hpp>
#include <columns/Factory.hpp>
#include <io/PVParams.hpp>
#include <io/io.hpp>
#include <iostream>

namespace PV {

class PV_Init {
  public:
   PV_Init(int *argc, char **argv[], bool allowUnrecognizedArguments);
   virtual ~PV_Init();

   int initialize();

   // Below are get-methods for retrieving command line arguments from the
   // Arguments object.  Note that there are both getParams and
   // getParamsFile methods.

   char **getArgsCopy() const;

   static void freeArgs(int argc, char **argv);

   int getNumArgs() const { return mArgC; }

   char const *getProgramName() const { return mArgV[0]; }

   Arguments const *getArguments() const { return arguments; }

   bool const &getBooleanArgument(std::string const &name) const {
      return arguments->getBooleanArgument(name);
   }

   int const &getIntegerArgument(std::string const &name) const {
      return arguments->getIntegerArgument(name);
   }

   unsigned int const &getUnsignedIntArgument(std::string const &name) const {
      return arguments->getUnsignedIntArgument(name);
   }

   std::string const &getStringArgument(std::string const &name) const {
      return arguments->getStringArgument(name);
   }

   Configuration::IntOptional const &getIntOptionalArgument(std::string const &name) const {
      return arguments->getIntOptionalArgument(name);
   }

   PVParams *getParams() { return params; }

   void printState() const { arguments->printState(); }

   // Below are set-methods for changing changing command line arguments
   // stored in the Arguments object, and doing any necessary
   // operations required by the change.

   bool setBooleanArgument(std::string const &name, bool const &value) {
      return arguments->setBooleanArgument(name, value);
   }

   bool setIntegerArgument(std::string const &name, int const &value) {
      return arguments->setIntegerArgument(name, value);
   }

   bool setUnsignedIntArgument(std::string const &name, unsigned int const &value) {
      return arguments->setUnsignedIntArgument(name, value);
   }

   bool setStringArgument(std::string const &name, std::string const &value) {
      return arguments->setStringArgument(name, value);
   }

   bool setIntOptionalArgument(std::string const &name, Configuration::IntOptional const &value) {
      return arguments->setIntOptionalArgument(name, value);
   }

   int setParams(char const *paramsFile);

   int setLogFile(char const *val, bool appendFlag = false);

   int setMPIConfiguration(int rows, int columns, int batchwidth);

   int resetState();

   Communicator *getCommunicator() { return mCommunicator; }

   int getWorldRank() const {
      if (mCommunicator) {
         return mCommunicator->globalCommRank();
      }
      else {
         int rank = 0;
         MPI_Comm_rank(MPI_COMM_WORLD, &rank);
         return rank;
      }
   }

   int getWorldSize() {
      if (mCommunicator) {
         return mCommunicator->globalCommSize();
      }
      else {
         int size = 0;
         MPI_Comm_size(MPI_COMM_WORLD, &size);
         return size;
      }
   }

   bool isExtraProc() { return mCommunicator->isExtraProc(); }

   int getMaxThreads() const { return maxThreads; }

   int registerKeyword(char const *keyword, ObjectCreateFn creator);

  private:
   int initSignalHandler();
   int initMaxThreads();
   int commInit(int *argc, char ***argv);

   void initLogFile(bool appendFlag);

   int createParams();

   void printInitMessage();

   int commFinalize();

   int mArgC = 0;
   std::vector<char const *> mArgV;
   PVParams *params;
   Arguments *arguments;
   int maxThreads;
   Communicator *mCommunicator;
};
}

#endif