SimpleClusterCandidate.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 SVD_SIMPLECLUSTERCANDIDATE_H
#define SVD_SIMPLECLUSTERCANDIDATE_H
 
#include <vxd/dataobjects/VxdID.h>
#include <svd/dataobjects/SVDShaperDigit.h>
#include <vector>
 
namespace Belle2 {
  namespace SVD {
 
    struct stripInCluster {
      int recoDigitIndex; 
      float charge; 
      float noise; 
      int cellID; 
      float time; 
      float timeError; 
    };
 
    class SimpleClusterCandidate {
 
    public:
 
      SimpleClusterCandidate(VxdID vxdID, bool isUside, int sizeHeadTail, double cutSeed, double cutAdjacent, double cutSNR,
                             int timeAlgorithm);
 
      SimpleClusterCandidate(VxdID vxdID, bool isUside, int sizeHeadTail, double cutSeed, double cutAdjacent, double cutSNR,
                             int timeAlgorithm,
                             const std::string& storeShaperDigitsName,
                             const std::string& storeRecoDigitsName);
 
      bool add(VxdID vxdID, bool isUside, struct  stripInCluster& aStrip);
 
      void finalizeCluster();
 
      bool isGoodCluster();
 
      VxdID getSensorID() {return m_vxdID;}
 
      bool isUSide() {return m_isUside;}
 
      float getCharge() const { return m_charge; }
 
      float getChargeError() const { return m_chargeError; }
 
      float getSeedCharge() const { return m_seedCharge; }
 
      float getTime() const;
      float get6SampleCoGTime() const { return m_6SampleTime; }
      float get3SampleCoGRawTime() const;
      float get3SampleELSRawTime() const;
 
      float getTimeError() const;
      float get6SampleCoGTimeError() const  { return m_6SampleTimeError; }
      float get3SampleCoGTimeError() const;
      float get3SampleELSTimeError() const;
 
      Belle2::SVDShaperDigit::APVFloatSamples getClsSamples() const;
 
      std::pair<int, std::vector<float>> getMaxSum3Samples() const;
 
      int getFirstFrame()
      {
        if (m_timeAlgorithm == 0)
          return 0;
        return getMaxSum3Samples().first;
      }
 
      float getPosition() const { return m_position; }
 
      float getPositionError() const { return m_positionError; }
 
      float getSNR() const { return m_SNR; }
 
      int size() const { return m_strips.size(); }
 
      const std::vector<stripInCluster> getStripsInCluster() const { return m_strips; };
 
    protected:
 
      bool m_stopCreationCluster = false;
 
      VxdID m_vxdID;
 
      bool m_isUside;
 
      int m_sizeHeadTail;
 
      double m_cutSeed;
 
      double m_cutAdjacent;
 
      double m_cutCluster;
 
      int m_timeAlgorithm = 0;
 
      float m_charge;
 
      float m_chargeError;
 
      float m_seedCharge;
 
      float m_6SampleTime;
 
      float m_6SampleTimeError;
 
      float m_position;
 
      float m_positionError;
 
      float m_SNR;
 
      float m_seedSNR;
 
      int m_seedIndex;
 
      //      int m_firstFrame = 0;
 
      std::vector<stripInCluster> m_strips;
 
      std::string m_storeShaperDigitsName;
 
      std::string m_storeRecoDigitsName;
 
    };
 
  }
 
}
 
#endif //SVD_SIMPLECLUSTERCANDIDATE_H