MdtCalibHit.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 * Mdt Calibration Input Event Data Model
 * --------------------------------------
 *
 * Author       : Martin Woudstra
 * Creation Date: 18 February 2004
 ***************************************************************************/
 
#ifndef MUONCALIBEVENT_MDTCALIBHIT_H
#define MUONCALIBEVENT_MDTCALIBHIT_H
// std
#include <cassert>
#include <cmath>
#include <iostream>
// other packages
 
// this package
#include "GeoPrimitives/GeoPrimitives.h"
#include "MuonPrepRawData/MdtPrepData.h"
 
// pre-declarations
namespace MuonGM {
    class MdtReadoutElement;
}
 
namespace MuonCalib {
    class MdtCalibHitBase;
    class IIdToFixedIdTool;
}  // namespace MuonCalib
 
class MsgStream;

 
class MdtCalibHit {
public:
    static const float kNoValue;  
    MdtCalibHit();                
 
    MdtCalibHit(
        const Muon::MdtPrepData *dig, const Amg::Vector3D &globalPos,
        const MuonGM::MdtReadoutElement *geo);  
    MdtCalibHit(const Muon::MdtPrepData *dig, const Amg::Vector3D &globalPos, const Amg::Vector3D &localPos,
                const MuonGM::MdtReadoutElement *geo);  
 
    MdtCalibHit(const Identifier &id, int tdc, int adc, const Amg::Vector3D &globalPos,
                const MuonGM::MdtReadoutElement
                    *geo);  
    MdtCalibHit(const Identifier &id, int tdc, int adc, const Amg::Vector3D &globalPos, const Amg::Vector3D &localPos,
                const MuonGM::MdtReadoutElement *geo);  
 
    void setPrepData(const Muon::MdtPrepData *dig);                    
    void setIdentifier(const Identifier &id);                          
    void setTdc(int tdc);                                              
    void setAdc(int adc);                                              
    void setGlobalPos(const Amg::Vector3D &globalPos);                 
    void setLocalPos(const Amg::Vector3D &localPos);                   
    void setGlobalPointOfClosestApproach(const Amg::Vector3D &point);  
    void setLocalPointOfClosestApproach(const Amg::Vector3D &point);   
    void setGeometry(const MuonGM::MdtReadoutElement *geo);            
    void setDriftTime(double t);                                       
    void setDriftRadius(double r, double sigmaR);                      
    void setDistanceToTrack(double dist, double sigmaDist);            
    void setTimeFromTrackDistance(double t, double sigmaT);  
    void setSlewingTime(double slew);                        
    void setLorentzTime(double lor);                         
    void setPropagationTime(double prop);         
    void setTimeOfFlight(double tof);             
    void setDistanceToReadout(double dist);       
    void setWiresagTime(float wsag);              
    inline void setTemperatureTime(float temp) {  
        m_temperatureTime = temp;
    }
    void setBackgroundTime(float bkgr);   
    void setBFieldPerp(float bfperp);     
    void setBFieldPara(float bfpara);     
    void setTemperature(float temp);      
    void setProjSag(float sag);           
    void setTubeT0(float t0);             
    void setTubeAdcCal(float adccal);     
    void setLocXtwin(float xtwin);        
    void setSigma2LocXtwin(float xtwin);  
 
    const MuonGM::MdtReadoutElement *geometry() const;          
    const Identifier &identify() const;                         
    const Amg::Vector3D &globalPosition() const;                
    const Amg::Vector3D &localPosition() const;                 
    const Amg::Vector3D &globalPointOfClosestApproach() const;  
    const Amg::Vector3D &localPointOfClosestApproach() const;   
    int tdcCount() const;                                       
    int adcCount() const;                                       
    double driftTime() const;                                   
    double driftRadius() const;                                 
    double sigmaDriftRadius() const;                            
    double sigma2DriftRadius() const;                           
    double signedDistanceToTrack() const;                       
    double sigmaDistanceToTrack() const;                        
    double sigma2DistanceToTrack() const;                       
    double distanceToReadout() const;                           
    double slewingTime() const;                                 
    double lorentzTime() const;                  
    double propagationTime() const;              
    double timeOfFlight() const;                 
    double timeFromTrackDistance() const;        
    double sigmaTimeFromTrackDistance() const;   
    double sigma2TimeFromTrackDistance() const;  
    double radialResidual() const;               
    double trackResidual() const;                
    double timeResidual() const;                 
    float WiresagTime() const;                   
    inline float TemperatureTime() const {       
        return m_temperatureTime;
    }
    float BackgroundTime() const;
    float bFieldPerp() const;   
    float bFieldPara() const;   
    float temperature() const;  
    float projSag() const;      
    float tubeT0() const;       
    float tubeAdcCal() const;   
    float xtwin() const;        
    float sigmaXtwin() const;   
    float sigma2Xtwin() const;  
 
    MuonCalib::MdtCalibHitBase *hitBase(
        const MuonCalib::IIdToFixedIdTool &) const;  
 
    std::ostream &dump(std::ostream &stream) const;  
    MsgStream &dump(MsgStream &sl) const;            
 
private:
    Identifier m_id;                               
    int m_tdc;                                     
    int m_adc;                                     
    const MuonGM::MdtReadoutElement *m_geometry;   
    Amg::Vector3D m_globalPosition;                
    Amg::Vector3D m_localPosition;                 
    Amg::Vector3D m_localPointOfClosestApproach;   
    Amg::Vector3D m_globalPointOfClosestApproach;  
    float m_driftTime;                             
    float m_driftRadius;                           
    float m_sigma2DriftRadius;                     
    float m_timeFromTrackDistance;                 
    float m_sigma2TimeFromTrackDistance;           
    float m_slewingTime;                           
    float m_lorentzTime;                           
    float m_propagationTime;                       
    float m_timeOfFlight;                          
    float m_distanceToReadout;                     
    float m_signedDistanceToTrack;                 
    float m_sigma2DistanceToTrack;                 
    float m_wiresagTime;                           
    float m_temperatureTime;                       
    float m_backgroundTime;                        
    float m_bFieldPerp;                            
    float m_bFieldPara;                            
    float m_temperature;                           
    float m_projSag;                               
    float m_tube_t0;                               
    float m_tube_adccal;                           
    float m_xtwin;                                 
    float m_sigma2XTwin;                           
};
 
inline MdtCalibHit::MdtCalibHit() :
    m_id(0),
    m_tdc(0),
    m_adc(0),
    m_geometry(0),
    m_globalPosition(kNoValue, kNoValue, kNoValue),
    m_localPosition(kNoValue, kNoValue, kNoValue),
    m_driftTime(kNoValue),
    m_driftRadius(kNoValue),
    m_sigma2DriftRadius(1.0),
    m_timeFromTrackDistance(kNoValue),
    m_sigma2TimeFromTrackDistance(kNoValue),
    m_slewingTime(0.0),
    m_lorentzTime(0.0),
    m_propagationTime(0.0),
    m_timeOfFlight(0),
    m_distanceToReadout(kNoValue),
    m_signedDistanceToTrack(kNoValue),
    m_sigma2DistanceToTrack(kNoValue),
    m_wiresagTime(0),
    m_temperatureTime(0),
    m_backgroundTime(0),
    m_bFieldPerp(kNoValue),
    m_bFieldPara(kNoValue),
    m_temperature(kNoValue),
    m_projSag(0),
    m_tube_t0(0),
    m_tube_adccal(0),
    m_xtwin(kNoValue),
    m_sigma2XTwin(kNoValue) {}
 
inline MdtCalibHit::MdtCalibHit(const Muon::MdtPrepData *dig, const Amg::Vector3D &globalPos, const MuonGM::MdtReadoutElement *geo) :
    m_id(dig->identify()),
    m_tdc(dig->tdc()),
    m_adc(dig->adc()),
    m_geometry(geo),
    m_globalPosition(globalPos),
    m_localPosition(kNoValue, kNoValue, kNoValue),
    m_driftTime(kNoValue),
    m_driftRadius(kNoValue),
    m_sigma2DriftRadius(1.0),
    m_timeFromTrackDistance(kNoValue),
    m_sigma2TimeFromTrackDistance(kNoValue),
    m_slewingTime(0.0),
    m_lorentzTime(0.0),
    m_propagationTime(0.0),
    m_timeOfFlight(0),
    m_distanceToReadout(kNoValue),
    m_signedDistanceToTrack(kNoValue),
    m_sigma2DistanceToTrack(kNoValue),
    m_wiresagTime(0),
    m_temperatureTime(0),
    m_backgroundTime(0),
    m_bFieldPerp(kNoValue),
    m_bFieldPara(kNoValue),
    m_temperature(kNoValue),
    m_projSag(0),
    m_tube_t0(0),
    m_tube_adccal(0),
    m_xtwin(kNoValue),
    m_sigma2XTwin(kNoValue) {}
 
inline MdtCalibHit::MdtCalibHit(const Muon::MdtPrepData *dig, const Amg::Vector3D &globalPos, const Amg::Vector3D &localPos,
                                const MuonGM::MdtReadoutElement *geo) :
    m_id(dig->identify()),
    m_tdc(dig->tdc()),
    m_adc(dig->adc()),
    m_geometry(geo),
    m_globalPosition(globalPos),
    m_localPosition(localPos),
    m_driftTime(kNoValue),
    m_driftRadius(kNoValue),
    m_sigma2DriftRadius(1.0),
    m_timeFromTrackDistance(kNoValue),
    m_sigma2TimeFromTrackDistance(kNoValue),
    m_slewingTime(0.0),
    m_lorentzTime(0.0),
    m_propagationTime(0.0),
    m_timeOfFlight(0),
    m_distanceToReadout(kNoValue),
    m_signedDistanceToTrack(kNoValue),
    m_sigma2DistanceToTrack(kNoValue),
    m_wiresagTime(0),
    m_temperatureTime(0),
    m_backgroundTime(0),
    m_bFieldPerp(kNoValue),
    m_bFieldPara(kNoValue),
    m_temperature(kNoValue),
    m_projSag(0),
    m_tube_t0(0),
    m_tube_adccal(0),
    m_xtwin(kNoValue),
    m_sigma2XTwin(kNoValue) {}
 
inline MdtCalibHit::MdtCalibHit(const Identifier &id, int tdc, int adc, const Amg::Vector3D &globalPos,
                                const MuonGM::MdtReadoutElement *geo) :
    m_id(id),
    m_tdc(tdc),
    m_adc(adc),
    m_geometry(geo),
    m_globalPosition(globalPos),
    m_localPosition(kNoValue, kNoValue, kNoValue),
    m_driftTime(kNoValue),
    m_driftRadius(kNoValue),
    m_sigma2DriftRadius(1.0),
    m_timeFromTrackDistance(kNoValue),
    m_sigma2TimeFromTrackDistance(kNoValue),
    m_slewingTime(0.0),
    m_lorentzTime(0.0),
    m_propagationTime(0.0),
    m_timeOfFlight(0),
    m_distanceToReadout(kNoValue),
    m_signedDistanceToTrack(kNoValue),
    m_sigma2DistanceToTrack(kNoValue),
    m_wiresagTime(0),
    m_temperatureTime(0),
    m_backgroundTime(0),
    m_bFieldPerp(kNoValue),
    m_bFieldPara(kNoValue),
    m_temperature(kNoValue),
    m_projSag(0),
    m_tube_t0(0),
    m_tube_adccal(0),
    m_xtwin(kNoValue),
    m_sigma2XTwin(kNoValue) {}
 
inline MdtCalibHit::MdtCalibHit(const Identifier &id, int tdc, int adc, const Amg::Vector3D &globalPos, const Amg::Vector3D &localPos,
                                const MuonGM::MdtReadoutElement *geo) :
    m_id(id),
    m_tdc(tdc),
    m_adc(adc),
    m_geometry(geo),
    m_globalPosition(globalPos),
    m_localPosition(localPos),
    m_driftTime(kNoValue),
    m_driftRadius(kNoValue),
    m_sigma2DriftRadius(1.0),
    m_timeFromTrackDistance(kNoValue),
    m_sigma2TimeFromTrackDistance(kNoValue),
    m_slewingTime(0.0),
    m_lorentzTime(0.0),
    m_propagationTime(0.0),
    m_timeOfFlight(0),
    m_distanceToReadout(kNoValue),
    m_signedDistanceToTrack(kNoValue),
    m_sigma2DistanceToTrack(kNoValue),
    m_wiresagTime(0),
    m_temperatureTime(0),
    m_backgroundTime(0),
    m_bFieldPerp(kNoValue),
    m_bFieldPara(kNoValue),
    m_temperature(kNoValue),
    m_projSag(0),
    m_tube_t0(0),
    m_tube_adccal(0),
    m_xtwin(kNoValue),
    m_sigma2XTwin(kNoValue) {}
 
inline void MdtCalibHit::setPrepData(const Muon::MdtPrepData *dig) {
    m_id = dig->identify();
    m_tdc = dig->tdc();
    m_adc = dig->adc();
}
 
inline void MdtCalibHit::setIdentifier(const Identifier &id) { m_id = id; }
 
inline void MdtCalibHit::setTdc(int tdc) { m_tdc = tdc; }
 
inline void MdtCalibHit::setAdc(int adc) { m_adc = adc; }
 
inline void MdtCalibHit::setGlobalPos(const Amg::Vector3D &globalPos) { m_globalPosition = globalPos; }
 
inline void MdtCalibHit::setLocalPos(const Amg::Vector3D &localPos) { m_localPosition = localPos; }
 
inline void MdtCalibHit::setGlobalPointOfClosestApproach(const Amg::Vector3D &point) { m_globalPointOfClosestApproach = point; }
 
inline void MdtCalibHit::setLocalPointOfClosestApproach(const Amg::Vector3D &point) { m_localPointOfClosestApproach = point; }
 
inline void MdtCalibHit::setGeometry(const MuonGM::MdtReadoutElement *geo) { m_geometry = geo; }
 
inline void MdtCalibHit::setDriftTime(double t) { m_driftTime = t; }
 
inline void MdtCalibHit::setDriftRadius(double r, double sigmaR) {
    m_driftRadius = r;
    m_sigma2DriftRadius = sigmaR * sigmaR;
}
 
inline void MdtCalibHit::setDistanceToTrack(double dist, double sigmaDist) {
    m_signedDistanceToTrack = dist;
    m_sigma2DistanceToTrack = sigmaDist * sigmaDist;
}
 
inline void MdtCalibHit::setTimeFromTrackDistance(double t, double sigmaT) {
    m_timeFromTrackDistance = t;
    m_sigma2TimeFromTrackDistance = sigmaT * sigmaT;
}
 
inline void MdtCalibHit::setSlewingTime(double slew) { m_slewingTime = slew; }
 
inline void MdtCalibHit::setLorentzTime(double lor) { m_lorentzTime = lor; }
 
inline void MdtCalibHit::setPropagationTime(double prop) { m_propagationTime = prop; }
 
inline void MdtCalibHit::setTimeOfFlight(double tof) { m_timeOfFlight = tof; }
 
inline void MdtCalibHit::setDistanceToReadout(double dist) { m_distanceToReadout = dist; }
 
inline void MdtCalibHit::setWiresagTime(float wsag) { m_wiresagTime = wsag; }
 
inline void MdtCalibHit::setBFieldPerp(float val) { m_bFieldPerp = val; }
 
inline void MdtCalibHit::setBFieldPara(float val) { m_bFieldPara = val; }
 
inline void MdtCalibHit::setTemperature(float val) { m_temperature = val; }
 
inline void MdtCalibHit::setProjSag(float val) { m_projSag = val; }
 
inline void MdtCalibHit::setTubeT0(float t0) { m_tube_t0 = t0; }
 
inline void MdtCalibHit::setTubeAdcCal(float adccal) { m_tube_adccal = adccal; }
 
inline void MdtCalibHit::setLocXtwin(float xtwin) { m_xtwin = xtwin; }
 
inline void MdtCalibHit::setSigma2LocXtwin(float sigma2XTwin) { m_sigma2XTwin = sigma2XTwin; }
 
inline const MuonGM::MdtReadoutElement *MdtCalibHit::geometry() const { return m_geometry; }
 
inline const Identifier &MdtCalibHit::identify() const { return m_id; }
 
inline const Amg::Vector3D &MdtCalibHit::globalPosition() const { return m_globalPosition; }
 
inline const Amg::Vector3D &MdtCalibHit::localPosition() const { return m_localPosition; }
 
inline const Amg::Vector3D &MdtCalibHit::globalPointOfClosestApproach() const { return m_globalPointOfClosestApproach; }
 
inline const Amg::Vector3D &MdtCalibHit::localPointOfClosestApproach() const { return m_localPointOfClosestApproach; }
 
inline int MdtCalibHit::tdcCount() const { return m_tdc; }
 
inline int MdtCalibHit::adcCount() const { return m_adc; }
 
inline double MdtCalibHit::driftTime() const { return m_driftTime; }
 
inline double MdtCalibHit::driftRadius() const { return m_driftRadius; }
 
inline double MdtCalibHit::sigmaDriftRadius() const { return std::sqrt(m_sigma2DriftRadius); }
 
inline double MdtCalibHit::sigma2DriftRadius() const { return m_sigma2DriftRadius; }
 
inline double MdtCalibHit::signedDistanceToTrack() const { return m_signedDistanceToTrack; }
 
inline double MdtCalibHit::sigmaDistanceToTrack() const { return std::sqrt(m_sigma2DistanceToTrack); }
 
inline double MdtCalibHit::sigma2DistanceToTrack() const { return m_sigma2DistanceToTrack; }
 
inline double MdtCalibHit::distanceToReadout() const { return m_distanceToReadout; }
 
inline double MdtCalibHit::slewingTime() const { return m_slewingTime; }
 
inline double MdtCalibHit::lorentzTime() const { return m_lorentzTime; }
 
inline double MdtCalibHit::propagationTime() const { return m_propagationTime; }
 
inline double MdtCalibHit::timeOfFlight() const { return m_timeOfFlight; }
 
inline double MdtCalibHit::timeFromTrackDistance() const { return m_timeFromTrackDistance; }
 
inline double MdtCalibHit::sigmaTimeFromTrackDistance() const { return std::sqrt(m_sigma2TimeFromTrackDistance); }
 
inline double MdtCalibHit::sigma2TimeFromTrackDistance() const { return m_sigma2TimeFromTrackDistance; }
 
inline double MdtCalibHit::radialResidual() const { return std::abs(m_driftRadius) - std::abs(m_signedDistanceToTrack); }
 
inline double MdtCalibHit::trackResidual() const { return m_signedDistanceToTrack - m_driftRadius; }
 
inline double MdtCalibHit::timeResidual() const { return m_driftTime - m_timeFromTrackDistance; }
 
inline float MdtCalibHit::tubeT0() const { return m_tube_t0; }
 
inline float MdtCalibHit::tubeAdcCal() const { return m_tube_adccal; }
 
inline float MdtCalibHit::xtwin() const { return m_xtwin; }
 
inline float MdtCalibHit::sigmaXtwin() const { return std::sqrt(m_sigma2XTwin); }
 
inline float MdtCalibHit::sigma2Xtwin() const { return m_sigma2XTwin; }
 
inline float MdtCalibHit::bFieldPerp() const { return m_bFieldPerp; }
 
inline float MdtCalibHit::bFieldPara() const { return m_bFieldPara; }
 
inline float MdtCalibHit::temperature() const { return m_temperature; }
 
inline float MdtCalibHit::projSag() const { return m_projSag; }
 
std::ostream &operator<<(std::ostream &stream, const MdtCalibHit &hit);
 
MsgStream &operator<<(MsgStream &sl, const MdtCalibHit &hit);
 
#endif  // MUONCALIBEVENT_MDTCALIBHIT_H