SVDEventInfo.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 <TObject.h>
#include <string>
#include <cmath>
#include <svd/dataobjects/SVDModeByte.h>
#include <svd/dataobjects/SVDTriggerType.h>
#include <framework/database/DBObjPtr.h>
#include <framework/dbobjects/HardwareClockSettings.h>
 
 
namespace Belle2 {
  class SVDEventInfo : public TObject {
  public:

    explicit SVDEventInfo(SVDModeByte mode = SVDModeByte(), SVDTriggerType type = SVDTriggerType()):
      m_modeByte(mode.getID()), m_triggerType(type.getType())
    {
      m_ModeByteMatch = true; m_TriggerTypeMatch = true; m_Xtalk = false; m_relativeTimeShift = 0;
    }

    ~SVDEventInfo() {}

    void setMatchTriggerType(bool triggermatch) {m_TriggerTypeMatch = triggermatch;}

    void setMatchModeByte(bool modematch) {m_ModeByteMatch = modematch;}

    void setModeByte(SVDModeByte mode) {m_modeByte = mode.getID();}

    void setTriggerType(SVDTriggerType type) {m_triggerType = type.getType();}

    void setCrossTalk(bool xtalk) {m_Xtalk = xtalk;}

    void setRelativeShift(int relativeShift) {m_relativeTimeShift = relativeShift;}

    void setNSamples(int nAPVsamples) {m_nAPVsamples = nAPVsamples;}

    bool getMatchTriggerType() {return m_TriggerTypeMatch;}

    bool getMatchModeByte() {return m_ModeByteMatch;}

    SVDModeByte getModeByte() const
    { return m_modeByte; }

    float getSVD2FTSWTimeShift(int firstFrame) const
    { return m_apvClockPeriod / 4 * (3 - SVDModeByte(m_modeByte).getTriggerBin() + 4 * firstFrame); }

    int getNSamples() const
    { return m_nAPVsamples; }

    float getSamplingDelayInNs() const
    {
      if (m_nAPVsamples == 3) {
 
        int nTriggerClocks = SVDModeByte(m_modeByte).getTriggerBin() + m_relativeTimeShift;
 
        return floor(nTriggerClocks / 4) * m_apvClockPeriod;
      }
 
      return 0;
    }

    int getRelativeShift() const
    {
      return m_relativeTimeShift;
    }

    double getTimeInFTSWReference(double time_in_SVD, int firstFrame) const
    {
      return time_in_SVD + getSamplingDelayInNs() + getSVD2FTSWTimeShift(firstFrame);
    }

    bool setAPVClock(DBObjPtr<HardwareClockSettings> hwClock)
    {
      if (hwClock.isValid())
        m_apvClockPeriod = 1. / hwClock->getClockFrequency(Const::EDetector::SVD, "sampling");
      else
        return false;
 
      return true;
    }

    double getTimeInSVDReference(double time_in_FTSW, int firstFrame) const
    {
      return time_in_FTSW - getSamplingDelayInNs() - getSVD2FTSWTimeShift(firstFrame);
    }

    SVDTriggerType getTriggerType() const
    { return SVDTriggerType(m_triggerType); }

    bool isCrossTalkEvent() { return m_Xtalk; }
 

    std::string toString() const
    {
      SVDModeByte thisMode(m_modeByte);
      SVDTriggerType thisType(m_triggerType);
 
      bool thisModeMatch(m_ModeByteMatch);
      bool thisTriggerMatch(m_TriggerTypeMatch);
      bool thisXtalk(m_Xtalk);
      int thisRelativeShift(m_relativeTimeShift);
      int thisNsamples(m_nAPVsamples);
 
      std::ostringstream os;
 
      os << " Full SVDModeByte: " << (unsigned int)thisMode << std::endl;
      os << " Triggerbin: " << (unsigned int) thisMode.getTriggerBin() << std::endl;
      os << "RunType: " << (unsigned int)thisMode.getRunType() << ", EventType: " << (unsigned int) thisMode.getEventType() <<
         ", DAQMode:  " << (unsigned int) thisMode.getDAQMode() << std::endl;
      os << " ModeByte Match: " << thisModeMatch << std::endl;
      os << " Trigger Type: " << (unsigned int)thisType.getType() << std::endl;
      os << " TriggerType Match: " << thisTriggerMatch << std::endl;
      os << " Cross Talk: " << (thisXtalk ? "true" : "false") << std::endl;
      os << " Relative Shift 3/6: " << (unsigned int)thisRelativeShift << std::endl;
      os << " Number of APV samples: " << (unsigned int)thisNsamples << std::endl;
      return os.str();
    }
 
  private:
 
    SVDModeByte::baseType m_modeByte = SVDModeByte::c_DefaultID; 
    SVDTriggerType::baseType m_triggerType;    
    bool m_ModeByteMatch; 
    bool m_TriggerTypeMatch; 
    bool m_Xtalk = false;    
    int m_relativeTimeShift = 0; 
    int m_nAPVsamples = 0; 

    double m_apvClockPeriod = 16000. / 509.;

    ClassDef(SVDEventInfo, 3);
 
  }; //class

} // namespace Belle2