Environment.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/LogConfig.h>
#include <framework/gearbox/Const.h>
 
#include <limits>
#include <list>
#include <memory>
#include <string>
#include <vector>
 
namespace Belle2 {
  class Path;

  class Environment {
 
  public:

    static Environment& Instance();

    const std::list<std::string>& getModuleSearchPaths() const;

    void setExternalsPath(const std::string& externalsPath) { m_externalsPath = externalsPath; };

    const std::string& getExternalsPath() const { return m_externalsPath; };

    void setNumberEventsOverride(unsigned int nevents) { m_numberEventsOverride = nevents; }

    unsigned int getNumberEventsOverride() const { return m_numberEventsOverride; }

    void setEntrySequencesOverride(const std::vector<std::string>& sequences) { m_entrySequencesOverride = sequences; }

    std::vector<std::string> getEntrySequencesOverride() const { return m_entrySequencesOverride; }

    unsigned int getNumberOfEvents() const;

    void setRunExperimentOverride(int run, int experiment) { m_run = run; m_experiment = experiment; }

    int getRunOverride() const { return m_run; }
    int getExperimentOverride() const { return m_experiment; }

    void setSkipEventsOverride(unsigned int skipEvents) { m_skipNEvents = skipEvents; }
    unsigned int getSkipEventsOverride() const { return m_skipNEvents; }

    bool isMC() const;

    void setRunType(Const::ERunType runType) { m_runType = runType; }
    Const::ERunType getRunType() const { return m_runType; }

    bool isCosmicRun() const { return (m_runType == Const::c_Cosmic); }

    bool isBeamRun() const { return (m_runType == Const::c_Beam); }

    unsigned int getNumberOfMCEvents() const { return m_mcEvents; }

    void setNumberOfMCEvents(unsigned int n) { m_mcEvents = n; }

    void setInputFilesOverride(const std::vector<std::string>& names) { m_inputFilesOverride = names; }

    const std::vector<std::string>& getInputFilesOverride() const { return m_inputFilesOverride; }

    void setSecondaryInputFilesOverride(const std::vector<std::string>& names) { m_secondaryInputFilesOverride = names; }

    const std::vector<std::string>& getSecondaryInputFilesOverride() const { return m_secondaryInputFilesOverride; }

    void setOutputFileOverride(const std::string& name) { m_outputFileOverride = name; }

    const std::string& getOutputFileOverride() const { return m_outputFileOverride; }

    std::string consumeOutputFileOverride(const std::string& moduleName);

    const std::string& getOutputFileOverrideModule() const { return m_outputFileOverrideModule; }

    void setNumberProcessesOverride(int nproc) { m_numberProcessesOverride = nproc; }

    void setNumberProcesses(int number) { m_numberProcesses = number; }

    int getNumberProcesses() const
    {
      if (m_numberProcessesOverride >= 0)
        return m_numberProcessesOverride;
      else
        return m_numberProcesses;
    }

    void setPicklePath(const std::string& path) { m_picklePath = path; }

    std::string getPicklePath() const { return m_picklePath; }

    void setSteering(const std::string& steering) { m_steering = steering; };

    const std::string& getSteering() const { return m_steering; };

    void setVisualizeDataFlow(bool on) { m_visualizeDataFlow = on; }

    bool getVisualizeDataFlow() const { return m_visualizeDataFlow; }

    void setNoStats(bool noStats) { m_noStats = noStats; }

    bool getNoStats() const { return m_noStats; }
    void setDryRun(bool dryRun) { m_dryRun = dryRun; }
    bool getDryRun() const { return m_dryRun; }

    void setJobInformation(const std::shared_ptr<Path>& path);

    void setRealm(LogConfig::ELogRealm realm);
    LogConfig::ELogRealm getRealm() const { return m_realm; }

    void setWriteSimSteps(const bool writeSimSteps) { m_writeSimSteps = writeSimSteps; }
    bool getWriteSimSteps() const { return m_writeSimSteps; }

    void printJobInformation() const;

    void setProfileModuleName(const std::string& name) { m_profileModuleName = name; }

    std::string getProfileModuleName() const { return m_profileModuleName; }

    void setLogLevelOverride(int level) { m_logLevelOverride = level; }

    int getLogLevelOverride() const { return m_logLevelOverride; }

    void setStreamingObjects(const std::vector<std::string>& strobjs) { m_streamingObjects = strobjs; }

    const std::vector<std::string>& getStreamingObjects() const { return m_streamingObjects; }
 
    // ZMQ Options
    bool getUseZMQ() const
    {
      return m_useZMQ;
    }

    void setUseZMQ(bool useZMQ)
    {
      m_useZMQ = useZMQ;
    }

    const std::string& getZMQSocketAddress() const
    {
      return m_zmqSocketAddress;
    }

    void setZMQSocketAddress(const std::string& zmqSocketAddress)
    {
      m_zmqSocketAddress = zmqSocketAddress;
    }

    unsigned int getZMQMaximalWaitingTime() const
    {
      return m_zmqMaximalWaitingTime;
    }

    void setZMQMaximalWaitingTime(unsigned int zmqMaximalWaitingTime)
    {
      m_zmqMaximalWaitingTime = zmqMaximalWaitingTime;
    }

    unsigned int getZMQEventBufferSize() const
    {
      return m_zmqEventBufferSize;
    }

    void setZMQEventBufferSize(unsigned int zmqEventBufferSize)
    {
      m_zmqEventBufferSize = zmqEventBufferSize;
    }

    unsigned int getZMQWorkerTimeout() const
    {
      return m_zmqWorkerTimeout;
    }

    void setZMQWorkerTimeout(unsigned int zmqWorkerTimeout)
    {
      m_zmqWorkerTimeout = zmqWorkerTimeout;
    }

    bool getZMQUseEventBackup() const
    {
      return m_zmqUseEventBackup;
    }

    void setZMQUseEventBackup(bool zmqUseEventBackup)
    {
      m_zmqUseEventBackup = zmqUseEventBackup;
    }

    bool getZMQRestartFailedWorkers() const
    {
      return m_zmqRestartFailedWorkers;
    }

    void setZMQRestartFailedWorkers(bool zmqRestartFailedWorkers)
    {
      m_zmqRestartFailedWorkers = zmqRestartFailedWorkers;
    }

    bool getZMQFailOnFailedWorkers() const
    {
      return m_zmqFailOnFailedWorkers;
    }

    void setZMQFailOnFailedWorkers(bool zmqFailOnFailedWorkers)
    {
      m_zmqFailOnFailedWorkers = zmqFailOnFailedWorkers;
    }
 
    // DAQ environment
    bool getZMQDAQEnvironment() const
    {
      return m_zmqDAQEnvironment;
    }

    void setZMQDAQEnvironment(bool zmqDAQ)
    {
      m_zmqDAQEnvironment = zmqDAQ;
    }

    int getZMQDAQFirstEventExp() const
    {
      return m_zmqDAQFirstEventExp;
    }

    void setZMQDAQFirstEventExp(int exp)
    {
      m_zmqDAQFirstEventExp = exp;
    }

    int getZMQDAQFirstEventRun() const
    {
      return m_zmqDAQFirstEventRun;
    }

    void setZMQDAQFirstEventRun(int run)
    {
      m_zmqDAQFirstEventRun = run;
    }

    bool isZMQDAQFirstEvent(int exp, int run)
    {
      if (exp == m_zmqDAQFirstEventExp && run == m_zmqDAQFirstEventRun)
        return true;
      else
        return false;
    }
 
  private:
 
    std::string m_externalsPath;  
    int m_numberProcesses;        
    std::string m_steering;       
    unsigned int m_numberEventsOverride;   
    std::vector<std::string> m_inputFilesOverride; 
    std::vector<std::string> m_secondaryInputFilesOverride; 
    std::vector<std::string>
    m_entrySequencesOverride; 
    std::string m_outputFileOverride; 
    std::string m_outputFileOverrideModule{""}; 
    int m_numberProcessesOverride; 
    int m_logLevelOverride; 
    bool m_visualizeDataFlow; 
    bool m_noStats; 
    bool m_dryRun; 
    std::string m_jobInfoOutput; 
    std::string m_profileModuleName; 
    std::string m_picklePath; 
    std::vector<std::string> m_streamingObjects;  
    unsigned int m_mcEvents; 
    int m_run; 
    int m_experiment; 
    Const::ERunType m_runType = Const::c_Beam; 
    unsigned int m_skipNEvents; 
    LogConfig::ELogRealm m_realm = LogConfig::c_None; 
    bool m_writeSimSteps; 
 
    // ZMQ specific settings
    bool m_useZMQ = false; 
    std::string m_zmqSocketAddress = ""; 
    unsigned int m_zmqMaximalWaitingTime = (3600 * 24) *
                                           1000; 
    unsigned int m_zmqEventBufferSize = 1; 
    unsigned int m_zmqWorkerTimeout =
      0; 
    bool m_zmqUseEventBackup = true; 
    bool m_zmqRestartFailedWorkers = true; 
    bool m_zmqFailOnFailedWorkers = true; 
    bool m_zmqDAQEnvironment = false;   
    int m_zmqDAQFirstEventExp = std::numeric_limits<int>::max(); 
    int m_zmqDAQFirstEventRun = std::numeric_limits<int>::max(); 

    Environment();

    Environment(const Environment&) = delete;

    Environment& operator=(const Environment&) = delete;

    ~Environment();
 
  };

} //end of namespace Belle2