BackgroundInfo.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/pcore/Mergeable.h>
#include <framework/dataobjects/BackgroundMetaData.h>
#include <framework/core/FrameworkExceptions.h>
#include <string>
#include <vector>
 
namespace Belle2 {
  class BackgroundInfo: public Mergeable {
 
  public:
 
    BELLE2_DEFINE_EXCEPTION(BackgroundInfoNotMergeable,
                            "BackgroundInfo: objects cannot be merged");
 
    enum EMethod {c_Unknown = 0, 
                  c_Mixing  = 1, 
                  c_Overlay = 2  
                 };
 
    struct BackgroundDescr {
      BackgroundMetaData::BG_TAG tag = BackgroundMetaData::bg_none;  
      std::string type; 
      BackgroundMetaData::EFileType fileType = BackgroundMetaData::c_Usual; 
      std::vector<std::string> fileNames; 
      double realTime = 0;         
      unsigned numEvents = 0;      
      double scaleFactor = 1;      
      double rate = 0;             
      unsigned reused = 0;         
    };
 
    BackgroundInfo()
    {}
 
    ~BackgroundInfo() {}
 
    void setMethod(EMethod method) {m_method = method;}
 
    unsigned appendBackgroundDescr(const BackgroundDescr& bgDescr)
    {
      m_backgrounds.push_back(bgDescr);
      return m_backgrounds.size() - 1;
    }
 
    void setComponents(const std::vector<std::string>& components)
    {
      m_components = components;
    }
 
    void setMinTime(double minTime) {m_minTime = minTime;}
 
    void setMaxTime(double maxTime) {m_maxTime = maxTime;}
 
    void setMinTimeECL(double minTimeECL) {m_minTimeECL = minTimeECL;}
 
    void setMaxTimeECL(double maxTimeECL) {m_maxTimeECL = maxTimeECL;}
 
    void setMinTimePXD(double minTimePXD) {m_minTimePXD = minTimePXD;}
 
    void setMaxTimePXD(double maxTimePXD) {m_maxTimePXD = maxTimePXD;}
 
    void setWrapAround(bool wrapAround) {m_wrapAround = wrapAround;}
 
    void setMaxEdepECL(double maxEdepECL) {m_maxEdepECL = maxEdepECL;}
 
    void setExtensionName(const std::string& name) {m_extensionName = name;}
 
    void incrementReusedCounter(unsigned index)
    {
      if (index < m_backgrounds.size()) m_backgrounds[index].reused++;
    }
 
    EMethod getMethod() const {return m_method;}
 
    const std::vector<BackgroundDescr>& getBackgrounds() const {return m_backgrounds;}
 
    const std::vector<std::string>& getComponents() const {return m_components;}
 
    double getMinTime() const {return m_minTime;}
 
    double getMaxTime() const {return m_maxTime;}
 
    double getMinTimeECL() const {return m_minTimeECL;}
 
    double getMaxTimeECL() const {return m_maxTimeECL;}
 
    double getMinTimePXD() const {return m_minTimePXD;}
 
    double getMaxTimePXD() const {return m_maxTimePXD;}
 
    bool getWrapAround() const {return m_wrapAround;}
 
    double getMaxEdepECL() const {return m_maxEdepECL;}
 
    const std::string& getExtensionName() const {return m_extensionName;}
 
    virtual void merge(const Mergeable* other) override;
 
    virtual void clear() override;
 
    void print() const;
 
  private:
 
    bool canBeMerged(const BackgroundInfo* other);
 
    void printForMixing() const;
 
    void printForOverlay() const;
 
    EMethod m_method = c_Unknown; 
    std::vector<BackgroundDescr> m_backgrounds; 
    std::vector<std::string> m_components; 
    double m_minTime = 0;  
    double m_maxTime = 0;  
    double m_minTimeECL = 0;  
    double m_maxTimeECL = 0;  
    double m_minTimePXD = 0;  
    double m_maxTimePXD = 0;  
    bool m_wrapAround = false; 
    double m_maxEdepECL = 0;  
    std::string m_extensionName; 
    ClassDefOverride(BackgroundInfo, 4); 
  };
}