SVDCluster.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.                  *
 **************************************************************************/
 
#ifndef SVDCLUSTER_H
#define SVDCLUSTER_H
 
#include <framework/datastore/RelationsObject.h>
#include <vxd/dataobjects/VxdID.h>
#include <vxd/geometry/SensorInfoBase.h>
#include <vxd/geometry/GeoCache.h>
 
#include <sstream>
#include <vector>
 
namespace Belle2 {

  class SVDCluster: public RelationsObject {
  public:

    SVDCluster(VxdID sensorID, bool isU, float position, float positionSigma,
               double clsTime, double clsTimeSigma, float clsCharge, float seedCharge,
               unsigned short clsSize, float clsSN, float clsChi2, int firstFrame = 0):
      m_clsTime(clsTime), m_clsTimeSigma(clsTimeSigma),
      m_position(position), m_positionSigma(positionSigma),
      m_clsCharge(clsCharge),  m_seedCharge(seedCharge), m_clsSN(clsSN),
      m_clsChi2(clsChi2), m_firstFrame(firstFrame),
      m_sensorID(sensorID), m_clsSize(clsSize), m_isU(isU)
    {}
    SVDCluster(VxdID sensorID, bool isU, float position, float positionSigma, {…}

    SVDCluster(): SVDCluster(0, false, 0.0, 1.0, 0.0, 100.0, 0.0, 0.0, 0, 1.0,
                               100.0)
    {}
    SVDCluster(): SVDCluster(0, false, 0.0, 1.0, 0.0, 100.0, 0.0, 0.0, 0, 1.0, {…}

    SVDCluster(VxdID sensorID, bool isU, float position, double clsTime,
               double clsTimeSigma, float clsCharge, float seedCharge,
               unsigned short clsSize):
      SVDCluster(sensorID, isU, position, 1.0, clsTime, clsTimeSigma,
                 clsCharge, seedCharge, clsSize, 1.0, 100.0)
    {}
    SVDCluster(VxdID sensorID, bool isU, float position, double clsTime, {…}

    SVDCluster(VxdID sensorID, bool isU, float position, float positionSigma,
               double clsTime, double clsTimeSigma, float clsCharge, float seedCharge,
               unsigned short clsSize, float clsSN):
      SVDCluster(sensorID, isU, position, positionSigma, clsTime, clsTimeSigma,
                 clsCharge, seedCharge, clsSize, clsSN, 100.0)
    {}
    SVDCluster(VxdID sensorID, bool isU, float position, float positionSigma, {…}

    VxdID getSensorID() const { return m_sensorID; }

    unsigned short getRawSensorID() const { return m_sensorID; }

    bool isUCluster() const { return m_isU; }

    float getPosition(double v = 0) const
    {
      if (v == 0) return m_position;
      else {
        const VXD::SensorInfoBase* aSensorInfo = &VXD::GeoCache::getInstance().getSensorInfo(m_sensorID);
        return (aSensorInfo->getWidth(v) / aSensorInfo->getWidth()) * m_position;
      }
    }
    float getPosition(double v = 0) const {…}

    float getPositionSigma() const { return m_positionSigma; }

    float getClsTime() const { return m_clsTime; }

    float getClsTimeSigma() const { return m_clsTimeSigma; }

    float getCharge() const { return m_clsCharge; }

    float getSeedCharge() const { return m_seedCharge; }

    unsigned short getSize() const { return m_clsSize; }

    float getSNR() const { return m_clsSN; }

    float getChi2() const { return m_clsChi2; }

    int getFirstFrame() const { return m_firstFrame; }

    double getQuality() const { return m_qualityIndicator; }

    double getQualityError() const { return m_qualityIndicatorError; }

    const std::vector<int>& getTimeGroupId() const { return m_timeGroupId; }

    const std::vector<std::tuple<float, float, float>>& getTimeGroupInfo() const { return m_timeGroupInfo; }

    void setPosition(const double position)
    {
      m_position = position;
    }
    void setPosition(const double position) {…}

    void setClsTime(const double time)
    {
      m_clsTime = time;
    }
    void setClsTime(const double time) {…}

    void setQualityIndicator(const double qualityIndicator)
    {
      m_qualityIndicator = qualityIndicator;
    }
    void setQualityIndicator(const double qualityIndicator) {…}

    void setQualityIndicatorError(double qualityIndicatorError)
    {
      m_qualityIndicatorError = qualityIndicatorError;
    }
    void setQualityIndicatorError(double qualityIndicatorError) {…}

    std::vector<int>& setTimeGroupId() { return m_timeGroupId; }

    std::vector<std::tuple<float, float, float>>& setTimeGroupInfo() { return m_timeGroupInfo; }

    std::string print() const
    {
      VxdID thisSensorID(m_sensorID);
      std::ostringstream os;
      os << "VXDID : " << m_sensorID << " = " << std::string(thisSensorID)
         << " side: " << ((m_isU) ? "U" : "V") << " position: " << m_position
         << " +/- " << m_positionSigma << " time: " << m_clsTime << " +/- "
         << m_clsTimeSigma << " charge: " << m_clsCharge << " seed charge: "
         << m_seedCharge << " size: " << m_clsSize << " S/N: " << m_clsSN
         << " Fit Chi2: " << m_clsChi2 <<  " Signal Prob.: " << m_qualityIndicator
         << " Signal Prob. Error " << m_qualityIndicatorError << std::endl;
      return os.str();
    }
    std::string print() const {…}
 
  protected:
    std::vector<int> m_timeGroupId;    
    std::vector<std::tuple<float, float, float>> m_timeGroupInfo; 
    double m_qualityIndicator = {0.};  
    double m_qualityIndicatorError = {0.};  
    double m_clsTime;          
    double m_clsTimeSigma;     
    float m_position;          
    float m_positionSigma;     
    float m_clsCharge;         
    float m_seedCharge;        
    float m_clsSN;             
    float m_clsChi2;           
    int m_firstFrame;           
    unsigned short m_sensorID; 
    unsigned short m_clsSize;  
    bool m_isU;                
 
    ClassDef(SVDCluster, 9)
 
  };
  class SVDCluster: public RelationsObject {…};
 

} //Belle2 namespace
#endif