JetScapeModuleBase.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file JetScapeModuleBase.h

/*******************************************************************************
 * Copyright (c) The JETSCAPE Collaboration, 2018
 *
 * Modular, task-based framework for simulating all aspects of heavy-ion collisions
 * 
 * For the list of contributors see AUTHORS.
 *
 * Report issues at https://github.com/JETSCAPE/JETSCAPE/issues
 *
 * or via email to bugs.jetscape@gmail.com
 *
 * Distributed under the GNU General Public License 3.0 (GPLv3 or later).
 * See COPYING for details.
 ******************************************************************************/

#ifndef JETSCAPEMODULEBASE_H
#define JETSCAPEMODULEBASE_H

#include <string>
#include <memory>
#include <random>
#include <map>

#include "JetScapeTask.h"
#include "JetScapeXML.h"
#include "sigslot.h"

namespace Jetscape {

class JetScapeWriter;

class JetScapeModuleBase
    : public JetScapeTask,
      public sigslot::has_slots<sigslot::multi_threaded_local> {

public:
  JetScapeModuleBase();

  JetScapeModuleBase(string m_name);

  virtual ~JetScapeModuleBase();

  //virtual shared_ptr<JetScapeModuleBase> Clone() const {return nullptr;}
  virtual void Init();

  virtual void Exec(){};

  virtual void Clear(){};

  void SetXMLMainFileName(string m_name) { xml_main_file_name = m_name; }

  string GetXMLMainFileName() { return xml_main_file_name; }

  void SetXMLUserFileName(string m_name) { xml_user_file_name = m_name; }

  string GetXMLUserFileName() { return xml_user_file_name; }

  static int GetCurrentEvent() { return current_event; }

  static void IncrementCurrentEvent() { current_event++; }

  shared_ptr<std::mt19937> GetMt19937Generator();

  tinyxml2::XMLElement *GetXMLElement(std::initializer_list<const char *> path,
                                      bool isRequired = true) {
    return JetScapeXML::Instance()->GetElement(path, isRequired);
  }
  std::string GetXMLElementText(std::initializer_list<const char *> path,
                                bool isRequired = true) {
    return JetScapeXML::Instance()->GetElementText(path, isRequired);
  }
  int GetXMLElementInt(std::initializer_list<const char *> path,
                       bool isRequired = true) {
    return JetScapeXML::Instance()->GetElementInt(path, isRequired);
  }
  double GetXMLElementDouble(std::initializer_list<const char *> path,
                             bool isRequired = true) {
    return JetScapeXML::Instance()->GetElementDouble(path, isRequired);
  }

private:
  std::string xml_main_file_name;
  std::string xml_user_file_name;
  static int current_event;
  shared_ptr<std::mt19937> mt19937_generator_;
};


template <typename T> shared_ptr<JetScapeModuleBase> createT() {
  return std::make_shared<T>();
}

// Factory to create and keep track of new modules
class JetScapeModuleFactory {
public:
  virtual ~JetScapeModuleFactory() {}

  typedef std::map<std::string, shared_ptr<JetScapeModuleBase> (*)()> map_type;

  static shared_ptr<JetScapeModuleBase> createInstance(std::string const &s) {
    map_type::iterator it = getMap()->find(s);
    if (it == getMap()->end()) {
      return 0;
    }
    return it->second();
  }

protected:
  static map_type *getMap() {
    // We never delete the map (until program termination) because we cannot guarantee correct destruction order
    if (!moduleMap) {
      moduleMap = new map_type;
    }
    return moduleMap;
  }

private:
  static map_type *moduleMap;
};

template <typename T>
class RegisterJetScapeModule : public JetScapeModuleFactory {
public:
  RegisterJetScapeModule(std::string const &s) {
    //std::cout << "Registering " << s << " to the map" << std::endl;
    getMap()->insert(std::make_pair(s, &createT<T>));
  }
};

} // end namespace Jetscape

#endif