TMDC.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// $Id: TMDC.h,v 1.9 2010/03/31 09:58:59 liucy Exp $
//-----------------------------------------------------------------------------
// Filename : TMDC.h
// Section  : Tracking MDC
// Owner    : Yoshi Iwasaki
// Email    : [email protected]
//-----------------------------------------------------------------------------
// Description : A class to represent MDC.
//               See http://bsunsrv1.kek.jp/~yiwasaki/tracking/
//-----------------------------------------------------------------------------
 
#ifndef TMDC_FLAG_
#define TMDC_FLAG_
 
#ifdef TRKRECO_DEBUG_DETAIL
#ifndef TRKRECO_DEBUG
#define TRKRECO_DEBUG
#endif
#endif
 
#include <cmath>
#include <string>
 
#define HEP_SHORT_NAMES
#include "CLHEP/Alist/AList.h"
#include "TrkReco/TUpdater.h"
 
#ifndef CLHEP_POINT3D_H
#include "CLHEP/Geometry/Point3D.h"
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Point3D<double> HepPoint3D;
#endif
 
class TMDC;
class TMDCWire;
class TMDCLayer;
class TMDCWireHit;
class TMDCWireHitMC;
//class Geocdc_wire;
//struct geocdc_wire;
//struct geocdc_layer;
//struct reccdc_wirhit;
class MdcRecGeo;
class MdcGeoWire;
class MdcGeoLayer;
class MdcRec_wirhit;
 
//class HepPoint3D;
class TMLink;
class TTrack;
 
/** A class to represent MDC.
 
  The instance of TMDC is a singleton. 'TMDC::getTMDC()' gives you a
  pointer to access the TMDC. Geometrical information is initialized
  automatically. Before accessing hit information, user has to call
  'update()' to initialize hit information event by event. */
 
class TMDC : private TUpdater {
 
  public:
    /// returns TMDC object.
    static TMDC * getTMDC(const std::string & cdcVersion);
    static TMDC * getTMDC(void);
 
  private:
    /// Constructor
    TMDC(const std::string & cdcVersion);
 
  public:// Selectors
    /// returns name.
    std::string name(void) const;
 
    /// returns version.
    std::string version(void) const;
 
    /// returns MDC version.
    std::string cdcVersion(void) const;
 
    /// dumps debug information.
    void dump(const std::string & message) const;
 
    /// returns debug level.
    int debugLevel(void) const;
 
    /// returns fudge factor for drift time error.
    float fudgeFactor(void) const;
 
  public:// to access information
    /// clears all TMDC information.
    void clear(void);
 
    /// clears TMDC information.
    void fastClear(void);
 
    /// updates TMDC information. clear() is called in this function.
    void update(bool mcAnalysis = true);
 
    /// sets debug level.
    int debugLevel(int);
 
    /// sets/returns fudge factor for drift time error.
    float fudgeFactor(float);
 
  public:// Geometry
    /// returns a pointer to a wire. 0 will be returned if 'wireId' is invalid.
    const TMDCWire * const wire(unsigned wireId) const;
 
    /// returns a pointer to a wire. 'localId' can be negative. 0 will be returned if 'layerId' is invalid.
    const TMDCWire * const wire(unsigned layerId, int localId) const;
 
    /// returns a pointer to a wire.
    const TMDCWire * const wire(const HepPoint3D & point) const;
 
    /// returns a pointer to a wire.
    const TMDCWire * const wire(float r, float phi) const;
 
    /// returns a pointer to a layer. 0 will be returned if 'id' is invalid.
    const TMDCLayer * const layer(unsigned id) const;
 
    /// returns a pointer to a super-layer. 0 will be returned if 'id' is invalid.
    const AList<TMDCLayer> * const superLayer(unsigned id) const;
 
    /// returns \# of wire layers in a super layer. 0 will be returned if 'superLayerId' is invalid.
    unsigned nLocalLayer(unsigned superLayerId) const;
 
  public:// Event by event information.
    /// returns a list of TMDCWireHit. 'update()' must be called before calling this function.
    const AList<TMDCWireHit> & hits(unsigned mask = 0) const;
 
    /// returns a list of axial hits. 'update()' must be called before calling this function.
    const AList<TMDCWireHit> & axialHits(unsigned mask = 0) const;
 
    /// returns a list of stereo hits. 'update()' must be called before calling this function.
    const AList<TMDCWireHit> & stereoHits(unsigned mask = 0) const;
 
    /// returns a list of TMDCWireHitMC. 'updateMC()' must be called before calling this function.
    const AList<TMDCWireHitMC> & hitsMC(void) const;
 
    /// returns bad hits(finding invalid hits).
    const AList<TMDCWireHit> & badHits(void);
 
  public:// Utility functions
    unsigned nWires(void) const;
    unsigned nSuperLayers(void) const;
    unsigned nLayers(void) const;
 
  public:// Utility functions for panther tables
    static std::string wireName(unsigned wireId);
    //    static std::string wireName(const geocdc_wire * const);
    //    static std::string wireName(const Geocdc_wire * const);
    //    static std::string wireName(const reccdc_wirhit &);
    static std::string wireName(const MdcGeoWire * const);
    static std::string wireName(const MdcRec_wirhit &);
 
    static unsigned layerId(unsigned wireId);
    //    static unsigned layerId(const geocdc_wire * const);
    //    static unsigned layerId(const Geocdc_wire * const);
    static unsigned layerId(const MdcGeoWire * const);
 
    static unsigned localId(unsigned wireId);
    //    static unsigned localId(const geocdc_wire * const);
    //    static unsigned localId(const Geocdc_wire * const);
    static unsigned localId(const MdcGeoWire * const);
 
    static unsigned superLayerId(unsigned wireId);
    //    static unsigned superLayerId(const geocdc_wire * const);
    //    static unsigned superLayerId(const Geocdc_wire * const);
    //    static unsigned superLayerId(const geocdc_layer * const);
    static unsigned superLayerId(const MdcGeoWire * const);
    static unsigned superLayerId(const MdcGeoLayer * const);
 
    static unsigned localLayerId(unsigned wireId);
    //    static unsigned localLayerId(const geocdc_wire * const);
    //    static unsigned localLayerId(const Geocdc_wire * const);
    //    static unsigned localLayerId(const geocdc_layer * const);
    static unsigned localLayerId(const MdcGeoWire * const);
    static unsigned localLayerId(const MdcGeoLayer * const);
 
 
    //    static unsigned axialStereoLayerId(const geocdc_layer * const);
    static unsigned axialStereoLayerId(const MdcGeoLayer * const);
    static unsigned layerId(unsigned axialStereo, unsigned axialStereoLayerId);
 
    static float phi(float phi);
 
    /// calculates corrected drift time. correctionFlag(bit 0:tof, 1:T0 offset, 2:propagation delay, 3:tan(lambda) correction)
    static void driftDistance(TMLink & link,
                  const TTrack & track,
                  unsigned correctionFlag = 0,
                  float T0Offset = 0.);
 
//  private:
    /// classify hits.
    void classification(void);
 
    /// updates TMDC information for MC.
    void updateMC(void);
 
  private:
    static TMDC * _cdc;
//    MdcRecGeo* _geo;
        
    int _debugLevel;
 
    const std::string _cdcVersion;
    const bool _newCdc;
    const unsigned _nWires;
    const unsigned _nSuperLayers;
    const unsigned _nLayers;
 
    float _fudgeFactor;
    AList< AList<TMDCLayer> > _superLayers;
    AList<TMDCLayer> _layers;
    AList<TMDCWire> _wires;
    AList<TMDCWire> _hitWires;
    AList<TMDCWireHit> _hits;
    AList<TMDCWireHit> _axialHits;
    AList<TMDCWireHit> _stereoHits;
    AList<TMDCWireHit> _badHits;
    AList<TMDCWireHitMC> _hitsMC;
};
 
//-----------------------------------------------------------------------------
 
#ifdef TMDC_NO_INLINE
#define inline
#else
#undef inline
#define TMDC_INLINE_DEFINE_HERE
#endif
 
#ifdef TMDC_INLINE_DEFINE_HERE
 
inline
int
TMDC::debugLevel(void) const {
    return _debugLevel;
}
 
inline
int
TMDC::debugLevel(int a) {
    return _debugLevel = a;
}
 
inline
unsigned
TMDC::nLocalLayer(unsigned superLayerId) const {
    AList<TMDCLayer> * superLayer = _superLayers[superLayerId];
    if (! superLayer) return 0;
    return superLayer->length();
}
 
inline
const TMDCLayer * const
TMDC::layer(unsigned id) const {
    return _layers[id];
}
 
inline
const AList<TMDCWireHitMC> &
TMDC::hitsMC(void) const {
    return _hitsMC;
}
 
inline
const AList<TMDCLayer> * const
TMDC::superLayer(unsigned id) const {
    return _superLayers[id];
}
 
inline
const TMDCWire * const
TMDC::wire(unsigned id) const {
    return _wires[id];
}
 
inline
float
TMDC::phi(float a) {
    static const float pi2 = 2. * M_PI;
    a = std::fmod(a, pi2);
    if (a < 0.) return a + pi2;
    return a;
}
 
inline
float
TMDC::fudgeFactor(void) const {
    return _fudgeFactor;
}
 
inline
float
TMDC::fudgeFactor(float a) {
    return _fudgeFactor = a;
}
 
inline
std::string
TMDC::cdcVersion(void) const {
    return std::string(_cdcVersion);
}
 
inline
unsigned
TMDC::nWires(void) const {
    return _nWires;
}
 
inline
unsigned
TMDC::nSuperLayers(void) const {
    return _nSuperLayers;
}
 
inline
unsigned
TMDC::nLayers(void) const {
    return _nLayers;
}
 
#endif
 
#undef inline
 
#endif /* TMDC_FLAG_ */