/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/TrkReco/TrkReco-00-08-59-patch4-slc6tag/TrkReco/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    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// 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;

class TMDC : private TUpdater {

  public:
    static TMDC * getTMDC(const std::string & cdcVersion);
    static TMDC * getTMDC(void);

  private:
    TMDC(const std::string & cdcVersion);

  public:// Selectors
    std::string name(void) const;

    std::string version(void) const;

    std::string cdcVersion(void) const;

    void dump(const std::string & message) const;

    int debugLevel(void) const;

    float fudgeFactor(void) const;

  public:// to access information
    void clear(void);

    void fastClear(void);

    void update(bool mcAnalysis = true);

    int debugLevel(int);

    float fudgeFactor(float);

  public:// Geometry
    const TMDCWire * const wire(unsigned wireId) const;

    const TMDCWire * const wire(unsigned layerId, int localId) const;

    const TMDCWire * const wire(const HepPoint3D & point) const;

    const TMDCWire * const wire(float r, float phi) const;

    const TMDCLayer * const layer(unsigned id) const;

    const AList<TMDCLayer> * const superLayer(unsigned id) const;

    unsigned nLocalLayer(unsigned superLayerId) const;

  public:// Event by event information.
    const AList<TMDCWireHit> & hits(unsigned mask = 0) const;

    const AList<TMDCWireHit> & axialHits(unsigned mask = 0) const;

    const AList<TMDCWireHit> & stereoHits(unsigned mask = 0) const;

    const AList<TMDCWireHitMC> & hitsMC(void) const;

    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);

    static void driftDistance(TMLink & link,
                              const TTrack & track,
                              unsigned correctionFlag = 0,
                              float T0Offset = 0.);

//  private:
    void classification(void);

    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_ */

---