Fun4AllOutputManager.h

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

// Tell emacs that this is a C++ source
//  -*- C++ -*-.
#ifndef FUN4ALL_FUN4ALLOUTPUTMANAGER_H
#define FUN4ALL_FUN4ALLOUTPUTMANAGER_H

#include "Fun4AllBase.h"

#include <limits>
#include <string>
#include <vector>

class PHCompositeNode;

class Fun4AllOutputManager : public Fun4AllBase
{
 public:
  ~Fun4AllOutputManager() override = default;

  void Print(const std::string &what = "ALL") const override;

  virtual int AddNode(const std::string & /*nodename*/)
  {
    return 0;
  }

  virtual int AddRunNode(const std::string & /*nodename*/)
  {
    return 0;
  }

  virtual int StripNode(const std::string & /*nodename*/)
  {
    return 0;
  }

  virtual int StripRunNode(const std::string & /*nodename*/)
  {
    return 0;
  }

  virtual void SaveRunNode(const int) { return; }
  virtual void SaveDstNode(const int) { return; }

  virtual int AddEventSelector(const std::string &recomodule);

  virtual int outfileopen(const std::string & /*nodename*/)
  {
    return 0;
  }

  int WriteGeneric(PHCompositeNode *startNode);

  virtual int Write(PHCompositeNode * /*startNode*/)
  {
    return 0;
  }

  virtual int WriteNode(PHCompositeNode * /*thisNode*/)
  {
    return 0;
  }

  virtual std::vector<std::string> *EventSelector()
  {
    return &m_EventSelectorsVector;
  }

  virtual std::vector<unsigned> *RecoModuleIndex()
  {
    return &m_RecoModuleIndexVector;
  }

  virtual int DoNotWriteEvent(std::vector<int> *retcodes) const;

  virtual unsigned int EventsWritten() const { return m_NEvents; }
  virtual void IncrementEvents(const unsigned int i) { m_NEvents += i; }
  virtual void SetEventsWritten(const unsigned int i) { m_NEvents = i; }
  virtual std::string OutFileName() const { return m_OutFileName; }
  void OutFileName(const std::string &name) { m_OutFileName = name; }
  void SetClosingScript(const std::string &script) { m_RunAfterClosingScript = script; }
  void SetClosingScriptArgs(const std::string &args) { m_ClosingArgs = args; }
  int RunAfterClosing();
  void UseFileRule() { m_UseFileRuleFlag = true; }
  bool ApplyFileRule() const { return m_UseFileRuleFlag; }
  void SetNEvents(const unsigned int nevt) { m_MaxEvents = nevt; }
  unsigned int GetNEvents() const { return m_MaxEvents; }

 protected:
  Fun4AllOutputManager(const std::string &myname);
  Fun4AllOutputManager(const std::string &myname, const std::string &outfname);

 private:
  bool m_UseFileRuleFlag{false};

  unsigned int m_NEvents{0};

  unsigned int m_MaxEvents{std::numeric_limits<unsigned int>::max()};

  std::string m_RunAfterClosingScript;

  std::string m_ClosingArgs;

  std::string m_OutFileName;

  std::vector<std::string> m_EventSelectorsVector;

  std::vector<unsigned> m_RecoModuleIndexVector;
};

#endif