TRGCDC.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.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to represent CDC.
//-----------------------------------------------------------------------------
 
#ifndef TRGCDC_FLAG_
#define TRGCDC_FLAG_
 
#define TRGCDC_UNDEFINED 999999
 
#include <vector>
#include "trg/trg/Clock.h"
#include "trg/trg/Signal.h"
 
class TFile;
class TTree;
class TClonesArray;
 
namespace HepGeom {
  template <class T> class Point3D;
}
 
namespace Belle2 {
  namespace CDC {
    class CDCGeometryPar;
  }
 
  class TRGTime;
  class TRGClock;
  class TRGLink;
  class TRGCDC;
  class TRGCDCWire;
  class TRGCDCLayer;
  class TRGCDCWireHit;
  class TRGCDCWireHitMC;
  class TRGCDCSegment;
  class TRGCDCSegmentHit;
  class TRGCDCFrontEnd;
  class TRGCDCMerger;
  class TRGCDCTSFBoard;
  class TRGCDCTracker2D;
  class TRGCDCTrackSegmentFinder;
  class TRGCDCPerfectFinder;
  class TRGCDCHoughFinder;
  class TRGCDCHough3DFinder;
  class TRGCDCFitter3D;
  class TRGCDCLUT;
  class TRGCDCTrack;
  class TRGCDCEventTime;
 
 
  class TRGCDC {
 
  public:
 
    enum EReturnValueType {TSF = 1 << 0,
                           ETF = 1 << 1,
                           find2D = 1 << 2,
                           fit2D = 1 << 3,
                           find3D = 1 << 4,
                           fit3D = 1 << 5,
                           any = TSF | ETF | find2D | fit2D | find3D | fit3D
                          };
 
    static TRGCDC* getTRGCDC(const std::string& configFile,
                             unsigned simulationMode = 0,
                             unsigned fastSimulationMode = 0,
                             unsigned firmwareSimulationMode = 0,
                             int firmwareSimulationStart = 0,
                             int firmwareSimulationStop = 32 * 32 - 1,
                             bool _makeRootFile = 0,
                             bool perfect2DFinder = false,
                             bool perfect3DFinder = false,
                             const std::string& innerTSLUTFile = "?",
                             const std::string& outerTSLUTFile = "?",
                             const std::string& rootTRGCDCFile = "?",
                             const std::string& rootFitter3DFile = "?",
                             unsigned houghFinderPeakMin = 5,
                             const std::string& houghMappingFilePlus = "?",
                             const std::string& houghMappingFileMinus = "?",
                             unsigned houghDoit = 2,
                             bool fLogicLUTTSF = 0,
                             bool fLRLUT = 1,
                             bool fFitter3Dsmclr = 0,
                             bool fFitter3Ds2DFit = 1,
                             bool fFitter3Ds2DFitDrift = 0,
                             double inefficiency = 0,
                             bool fileTSF = 0,
                             bool fileETF = 0,
                             int fverETF = 0,
                             bool fprintFirmETF = 0,
                             bool fileHough3D = 0,
                             int finder3DMode = 0,
                             bool fileFitter3D = 0,
                             bool fXtSimpleFitter3D = 0,
                             double TdcBinWidth = 1.,
                             int trgCDCDataInputMode = 0,
                             const std::string& cdchitCollectionName = "");
 
    static TRGCDC* getTRGCDC(void);
 
  private:
 
    TRGCDC(const std::string& configFile,
           unsigned simulationMode,
           unsigned fastSimulationMode,
           unsigned firmwareSimulationMode,
           int firmwareSimulationStart,
           int firmwareSimulationStop,
           bool makeRootFile,
           bool perfect2DFinder,
           bool perfect3DFinder,
           const std::string& innerTSLUTFile,
           const std::string& outerTSLUTFile,
           const std::string& rootTRGCDCFile,
           const std::string& rootFitter3DFile,
           unsigned houghFinderPeakMin,
           const std::string& houghMappingFilePlus,
           const std::string& houghMappingFileMinus,
           unsigned houghDoit,
           bool fLogicLUTTSF,
           bool fLRLUT,
           bool fFitter3Dsmclr,
           bool fFitter3Ds2DFit,
           bool fFitter3Ds2DFitDrift,
           double inefficiecny,
           bool fileTSF,
           bool fileETF,
           int fverETF,
           bool fprintFirmETF,
           bool fileHough3D,
           int finder3DMode,
           bool fileFitter3D,
           bool fXtSimpleFitter3D,
           double TdcBinWidth,
           int trgCDCDataInputMode,
           const std::string& cdchitCollectionName);
 
    virtual ~TRGCDC();
 
    void initialize(unsigned houghFinderPeakMin,
                    const std::string& houghMappingFilePlus,
                    const std::string& houghMappingFileMinus,
                    unsigned houghDoit);
 
    void configure(void);
 
    void simulate(void);
 
    void storeSimulationResults(std::string collection2Dfinder,
                                std::string collection2Dfitter,
                                std::string collection3Dfitter);
 
    void terminate(void);
 
 
  public:// Selectors
 
    std::string name(void) const;
 
    std::string version(void) const;
 
    std::string versionCDC(void) const;
 
    unsigned mode(void) const;
 
    unsigned mode(unsigned);
 
    unsigned firmwareSimulationMode(void) const;
 
    int getReturnValue(void) const;
 
    int getReturnValue(EReturnValueType const& moduleName) const;
 
    void setReturnValue(EReturnValueType const& moduleName, bool flag);
 
    void setReturnValue(int);
 
    void dump(const std::string& message) const;
 
    int debugLevel(void) const;
 
    int debugLevel(int) const;
 
    float fudgeFactor(void) const;
 
    float fudgeFactor(float);
 
    std::vector<TRGCDCTrack*> getTrackList2D(void);
 
    std::vector<TRGCDCTrack*> getTrackList2DFitted(void);
 
    std::vector<TRGCDCTrack*> getTrackList3D(void);
 
    std::string getCDCHitCollectionName() const { return _cdchitCollectionName; }
 
  public:// Geometry
 
    CDC::CDCGeometryPar* m_cdcp;
 
    const TRGCDCWire* wire(unsigned wireId) const;
 
    const TRGCDCWire* wire(unsigned layerId, int localId) const;
 
//    const TRGCDCWire * wire(const HepGeom::Point3D<double> & point) const;
 
    const TRGCDCWire* wire(float r, float phi) const;
 
    const TRGCDCLayer* layer(unsigned id) const;
 
    const std::vector<TRGCDCLayer*>* superLayer(unsigned id) const;
 
    unsigned nLocalLayers(unsigned superLayerId) const;
 
    unsigned nWires(void) const;
 
    unsigned nSuperLayers(void) const;
 
    unsigned nLayers(void) const;
 
    unsigned nAxialLayers(void) const;
 
    unsigned nStereoLayers(void) const;
 
    unsigned nAxialSuperLayers(void) const;
 
    unsigned nStereoSuperLayers(void) const;
 
    float cellWidth(unsigned superLayerId) const;
 
    float superLayerR(unsigned superLayerId) const;
 
    float superLayerR2(unsigned superLayerId) const;
 
    unsigned nSegments(void) const;
 
    const TRGCDCSegment& segment(unsigned id) const;
 
    const TRGCDCSegment& segment(unsigned lyrId, unsigned id) const;
 
    const TRGCDCSegment& axialSegment(unsigned lyrId, unsigned id) const;
 
    const TRGCDCSegment& stereoSegment(unsigned lyrId, unsigned id) const;
 
    unsigned nSegmentLayers(void) const;
 
    const TRGCDCLayer* segmentLayer(unsigned id) const;
 
    unsigned nSegments(unsigned id) const;
 
  public:// Event by event hit information.
 
    void clear(void);
 
    void fastClear(void);
 
    void update();
 
    void updateByData(int inputMode);
 
    std::vector<const TRGCDCWireHit*> hits(void) const;
 
    std::vector<const TRGCDCWireHit*> axialHits(void) const;
 
    std::vector<const TRGCDCWireHit*> stereoHits(void) const;
 
    std::vector<const TRGCDCSegmentHit*> segmentHits(void) const;
 
    std::vector<const TRGCDCSegmentHit*> segmentHits(unsigned) const;
 
    std::vector<const TRGCDCSegmentHit*> axialSegmentHits(unsigned) const;
 
    std::vector<const TRGCDCSegmentHit*> stereoSegmentHits(unsigned) const;
 
    std::vector<const TRGCDCWireHitMC*> hitsMC(void) const;
 
//  std::vector<const TRGCDCWireHit *> badHits(void) const;
 
    int getEventTime(void) const;
 
  public:// Utility functions
 
    std::string wireName(unsigned wireId) const;
 
    unsigned localId(unsigned wireId) const;
 
    unsigned layerId(unsigned wireId) const;
 
    unsigned layerId(unsigned axialStereoSwitch,
                     unsigned axialStereoLayerId) const;
 
    unsigned superLayerId(unsigned wireId) const;
 
    unsigned localLayerId(unsigned wireId) const;
 
    unsigned axialStereoSuperLayerId(unsigned axialStereo,
                                     unsigned axialStereoLayerId) const;
 
    bool neighbor(const TRGCDCWire& w0, const TRGCDCWire& w1) const;
 
    void perfect3DFinder(std::vector<TRGCDCTrack*> trackList) const;
 
//     static void driftDistance(TLink & link,
//                               const TTrack & track,
//                               unsigned correctionFlag = 0,
//                               float T0Offset = 0.);
 
  public:// TRG information
 
    const TRGClock& systemClock(void) const;
 
    const TRGClock& systemClockFE(void) const;
 
    const TRGClock& TDCClock(void) const;
 
    const TRGClock& dataClock(void) const;
 
    int firmwareSimulationStart(void) const;
 
    int firmwareSimulationStop(void) const;
 
    int firmwareSimulationStartDataClock(void) const;
 
    int firmwareSimulationStopDataClock(void) const;
 
    const TRGClock& userClock3125(void) const;
 
    double systemOffsetMC(void) const;
 
    const TRGCDCFrontEnd* frontEnd(unsigned id) const;
 
    const TRGCDCMerger* merger(unsigned id) const;
 
//  const TRGCDCTrackSegmentFinder * tsfboard(unsigned id) const;
    TRGCDCTrackSegmentFinder* tsfboard(unsigned id) const;
 
    const TRGCDCTracker2D* tracker2D(unsigned id) const;
 
  private:
 
    void classification(void);
 
    void updateMC(void);
 
    void fastSimulation(void);
 
    void firmwareSimulation(void);
 
  private:
 
    static TRGCDC* _cdc;
 
    mutable int _debugLevel;
 
    const std::string _cdcVersion;
 
    std::string _configFilename;
 
    unsigned _simulationMode;
 
    unsigned _fastSimulationMode;
 
    unsigned _firmwareSimulationMode;
 
    int _firmwareSimulationStart;
 
    int _firmwareSimulationStop;
 
    TRGSignal _firmwareSimulationWindow;
 
    int _firmwareSimulationStartDataClock;
 
    int _firmwareSimulationStopDataClock;
 
    int _returnValue;
 
    std::vector<TRGCDCTrack*> _trackList2D;
 
    std::vector<TRGCDCTrack*> _trackList2DFitted;
 
    std::vector<TRGCDCTrack*> _trackList3D;
 
    bool _makeRootFile;
 
    const bool _perfect2DFinder;
 
    const bool _perfect3DFinder;
 
    std::string _innerTSLUTFilename;
 
    std::string _outerTSLUTFilename;
 
    std::string _rootTRGCDCFilename;
 
    std::string _rootFitter3DFilename;
 
    bool _fLogicLUTTSF;
 
    bool _fLRLUT;
 
    bool _fFitter3Dsmclr;
 
    bool _fFitter3Ds2DFit;
 
    bool _fFitter3Ds2DFitDrift;
 
    double _inefficiency;
 
    bool _fileTSF;
 
    bool _fileETF;
 
    int _fverETF;
 
    bool _fprintFirmETF;
 
    bool _fileHough3D;
 
    int _finder3DMode;
 
    bool _fileFitter3D;
 
    bool _fXtSimpleFitter3D;
 
    std::vector<std::vector<TRGCDCLayer*> *> _superLayers;
 
    std::vector<std::vector<TRGCDCLayer*> *> _axialSuperLayers;
 
    std::vector<std::vector<TRGCDCLayer*> *> _stereoSuperLayers;
 
    std::vector<TRGCDCLayer*> _layers;
 
    std::vector<TRGCDCLayer*> _axialLayers;
 
    std::vector<TRGCDCLayer*> _stereoLayers;
 
    std::vector<TRGCDCWire*> _wires;
 
    std::vector<TRGCDCWire*> _hitWires;
 
    std::vector<TRGCDCWireHit*> _hits;
 
    std::vector<TRGCDCWireHit*> _axialHits;
 
    std::vector<TRGCDCWireHit*> _stereoHits;
 
    std::vector<TRGCDCWireHit*> _badHits;
 
    std::vector<TRGCDCWireHitMC*> _hitsMC;
 
    std::vector<TRGCDCSegment*> _tss;
 
    std::vector<TRGCDCSegment*> _tsSL[9];
 
    std::vector<TRGCDCLayer*> _tsLayers;
 
    std::vector<TRGCDCSegmentHit*> _segmentHits;
 
    std::vector<TRGCDCSegmentHit*> _segmentHitsSL[9];
 
    float _fudgeFactor;
 
    float* _width;
 
    float* _r;
 
    float* _r2;
 
    const TRGClock _clock;
 
    const TRGClock _clockFE;
 
    const TRGClock _clockTDC;
 
    const TRGClock _clockD;
 
    const TRGClock _clockUser3125;
 
    const TRGClock _clockUser6250;
 
    const double _offset;
 
    std::vector<TRGLink*> _links;
 
    std::vector<TRGCDCFrontEnd*> _fronts;
 
    std::vector<TRGCDCMerger*> _mergers;
 
    std::vector <TRGCDCTrackSegmentFinder*> _tsfboards;
 
    std::vector <TRGCDCTracker2D*> _tracker2Ds;
 
    TRGCDCTrackSegmentFinder* _tsFinder;
 
    TRGCDCPerfectFinder* _pFinder;
 
    TRGCDCPerfectFinder* _p3DFinder;
 
    TRGCDCHoughFinder* _hFinder;
 
    TRGCDCHough3DFinder* _h3DFinder;
 
    TRGCDCFitter3D* _fitter3D;
 
    std::vector<TRGCDCEventTime*> _eventTime;
 
    int m_eventNum;
 
    TFile* m_file;
 
    TTree* m_tree;
 
    TTree* m_treeAllTracks;
 
    TTree* _tree2D;
 
    TClonesArray* m_fitParameters;
 
    TClonesArray* m_mcParameters;
 
    TClonesArray* m_mcTrack4Vector;
 
    TClonesArray* m_mcTrackVertexVector;
 
    TClonesArray* m_mcTrackStatus;
 
    TClonesArray* m_evtTime;
 
    TClonesArray* _tracks2D;
 
    int _trgCDCDataInputMode;
 
    std::string _cdchitCollectionName;
 
    //int m_minCDCTdc;
    //int m_maxCDCTdc;
    //int m_minTRGTdc;
    //int m_maxTRGTdc;
    TTree* m_treeROOTInput;
    TClonesArray* m_rootCDCHitInformation;
    TClonesArray* m_rootTRGHitInformation;
    //TClonesArray* m_CDCTRGTimeMatch;
    TClonesArray* m_rootTRGRawInformation;
 
    void saveCDCHitInformation(std::vector<std::vector<unsigned> >&);
    void saveTRGHitInformation(std::vector<std::vector<int > >&);
    void saveTRGRawInformation(std::vector<std::string >&);
    //void saveCDCTRGTimeMatchInformation(std::vector<std::vector<std::map<int, int > > >& );
 
    friend class TRGCDCModule;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  int
  TRGCDC::debugLevel(void) const
  {
    return _debugLevel;
  }
 
  inline
  int
  TRGCDC::debugLevel(int a) const
  {
    return _debugLevel = a;
  }
 
  inline
  unsigned
  TRGCDC::nLocalLayers(unsigned superLayerId) const
  {
    std::vector<TRGCDCLayer*>* superLayer = _superLayers[superLayerId];
    if (! superLayer) return 0;
    return superLayer->size();
  }
 
  inline
  const TRGCDCLayer*
  TRGCDC::layer(unsigned id) const
  {
    return _layers[id];
  }
 
  inline
  const std::vector<TRGCDCLayer*>*
  TRGCDC::superLayer(unsigned id) const
  {
    return _superLayers[id];
  }
 
  inline
  float
  TRGCDC::fudgeFactor(void) const
  {
    return _fudgeFactor;
  }
 
  inline
  float
  TRGCDC::fudgeFactor(float a)
  {
    return _fudgeFactor = a;
  }
 
  inline
  std::string
  TRGCDC::versionCDC(void) const
  {
    return std::string(_cdcVersion);
  }
 
  inline
  unsigned
  TRGCDC::nWires(void) const
  {
    return _wires.size();
  }
 
  inline
  unsigned
  TRGCDC::nSuperLayers(void) const
  {
    return _superLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::nStereoLayers(void) const
  {
    return _stereoLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::nAxialLayers(void) const
  {
    return _axialLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::nAxialSuperLayers(void) const
  {
    return _axialSuperLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::nStereoSuperLayers(void) const
  {
    return _stereoSuperLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::nLayers(void) const
  {
    return _layers.size();
  }
 
  inline
  float
  TRGCDC::cellWidth(unsigned a) const
  {
    return _width[a];
  }
 
  inline
  float
  TRGCDC::superLayerR(unsigned i) const
  {
    return _r[i];
  }
 
  inline
  float
  TRGCDC::superLayerR2(unsigned i) const
  {
    return _r2[i];
  }
 
  inline
  const TRGCDCSegment&
  TRGCDC::segment(unsigned id) const
  {
    return * _tss[id];
  }
 
  inline
  const TRGCDCSegment&
  TRGCDC::axialSegment(unsigned a, unsigned b) const
  {
    return * _tsSL[a * 2][b];
  }
 
  inline
  const TRGCDCSegment&
  TRGCDC::stereoSegment(unsigned a, unsigned b) const
  {
    return * _tsSL[a * 2 + 1][b];
  }
 
  inline
  unsigned
  TRGCDC::nSegments(void) const
  {
    return _tss.size();
  }
 
  inline
  const TRGClock&
  TRGCDC::systemClock(void) const
  {
    return _clock;
  }
 
  inline
  const TRGClock&
  TRGCDC::systemClockFE(void) const
  {
    return _clockFE;
  }
 
  inline
  const TRGClock&
  TRGCDC::TDCClock(void) const
  {
    return _clockTDC;
  }
 
  inline
  const TRGClock&
  TRGCDC::dataClock(void) const
  {
    return _clockD;
  }
 
  inline
  double
  TRGCDC::systemOffsetMC(void) const
  {
    return _offset;
  }
 
  inline
  std::vector<const TRGCDCSegmentHit*>
  TRGCDC::segmentHits(void) const
  {
    std::vector<const TRGCDCSegmentHit*> t;
    t.assign(_segmentHits.begin(), _segmentHits.end());
    return t;
  }
 
  inline
  std::vector<const TRGCDCSegmentHit*>
  TRGCDC::segmentHits(unsigned a) const
  {
    std::vector<const TRGCDCSegmentHit*> t;
    t.assign(_segmentHitsSL[a].begin(), _segmentHitsSL[a].end());
    return t;
  }
 
  inline
  std::vector<const TRGCDCSegmentHit*>
  TRGCDC::axialSegmentHits(unsigned a) const
  {
    std::vector<const TRGCDCSegmentHit*> t;
    t.assign(_segmentHitsSL[a * 2].begin(), _segmentHitsSL[a * 2].end());
    return t;
  }
 
  inline
  std::vector<const TRGCDCSegmentHit*>
  TRGCDC::stereoSegmentHits(unsigned a) const
  {
    std::vector<const TRGCDCSegmentHit*> t;
    t.assign(_segmentHitsSL[a * 2 + 1].begin(),
             _segmentHitsSL[a * 2 + 1].end());
    return t;
  }
 
  inline
  const TRGCDCFrontEnd*
  TRGCDC::frontEnd(unsigned a) const
  {
    return _fronts[a];
  }
 
  inline
  const TRGCDCMerger*
  TRGCDC::merger(unsigned a) const
  {
    return _mergers[a];
  }
 
  inline
  TRGCDCTrackSegmentFinder*
  TRGCDC::tsfboard(unsigned a)const
  {
    return _tsfboards[a];
  }
 
  inline
  const TRGCDCTracker2D*
  TRGCDC::tracker2D(unsigned a)const
  {
    return _tracker2Ds[a];
  }
 
  inline
  const TRGCDCLayer*
  TRGCDC::segmentLayer(unsigned id) const
  {
    if (id < _tsLayers.size())
      return _tsLayers[id];
    return 0;
  }
 
  inline
  unsigned
  TRGCDC::nSegmentLayers(void) const
  {
    return _tsLayers.size();
  }
 
  inline
  unsigned
  TRGCDC::mode(void) const
  {
    return _simulationMode;
  }
 
  inline
  unsigned
  TRGCDC::mode(unsigned a)
  {
    return _simulationMode = a;
  }
 
  inline
  unsigned
  TRGCDC::firmwareSimulationMode(void) const
  {
    return _firmwareSimulationMode;
  }
 
  inline
  int
  TRGCDC::getReturnValue(void) const
  {
    return _returnValue;
  }
 
  inline
  void
  TRGCDC::setReturnValue(int returnValue)
  {
    _returnValue = returnValue;
  }
 
  inline
  int
  TRGCDC::firmwareSimulationStart(void) const
  {
    return _firmwareSimulationStart;
  }
 
  inline
  int
  TRGCDC::firmwareSimulationStop(void) const
  {
    return _firmwareSimulationStop;
  }
 
  inline
  int
  TRGCDC::firmwareSimulationStartDataClock(void) const
  {
    return _firmwareSimulationStartDataClock;
  }
 
  inline
  int
  TRGCDC::firmwareSimulationStopDataClock(void) const
  {
    return _firmwareSimulationStopDataClock;
  }
 
} // namespace Belle2
 
#endif /* TRGCDC_FLAG_ */