Segment.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : Segment.h
// Section  : TRG CDC
// Owner    : Yoshihito Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent a wire in CDC.
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCSegment_FLAG_
#define TRGCDCSegment_FLAG_
 
#include <vector>
#include "trg/cdc/LUT.h"
#include "trg/cdc/Cell.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCSegment TRGCDCSegment
#endif
 
namespace Belle2 {
  class TRGSignal;
  class TRGCDCWire;
  class TRGCDCLayer;
  class TRGCDCLUT;
  class TRGCDCWireHit;
  class TRGCDCSegmentHit;
  class CDCTriggerSegmentHit;
 
  class TRGCDCSegment : public TRGCDCCell {
 
  public:
 
    TRGCDCSegment(unsigned id,
                  const TRGCDCLayer& layer,
                  const TRGCDCWire& w,
                  const TRGClock& clock,
                  const std::string& TSLUTFile,
                  const std::vector<const TRGCDCWire*>& wires);
 
    virtual ~TRGCDCSegment();
 
  public:// Selectors
 
    const std::vector<const TRGCDCWire*>& wires(void) const;
 
    std::string name(void) const override;
 
    const TRGCDCWire* operator[](unsigned id) const;
 
    const TRGCDCWire& center(void) const;
 
    const TRGCDCWire& priority(void) const;
 
    const TRGSignal& signal(void) const override;
 
    const TRGCDCSegmentHit* hit(void) const;
 
    const std::vector<const CDCTriggerSegmentHit*> storeHits(void) const;
 
    unsigned hitPattern(void) const;
    unsigned hitPattern(int clk0, int clk1) const;
    unsigned lutPattern(void) const;
    unsigned lutPattern(int clk0, int clk1) const;
 
    float fastestTime(void) const;
    float fastestTime(int clk0) const;
 
    float foundTime(void)const;
 
    float priorityTime(void) const;
 
    int priorityPosition(void)const;
    int priorityPosition(int clk0, int clk1)const;
 
    const TRGCDCLUT* LUT(void) const;
 
    void dump(const std::string& message = std::string(""),
              const std::string& prefix = std::string("")) const override;
 
 
    void initialize(void);
    void initialize(bool fevtTime);
 
  public:// Utility functions
 
    /*     static const std::vector<const TRGCDCSegment *> */
    /*  axial(const std::vector<const TRGCDCSegment *> & list); */
 
    static unsigned
    nStereo(const std::vector<const TRGCDCSegment*>& list);
 
    virtual bool hasMember(const std::string& a) const override;
 
  public:// Modifiers
 
    void clear(void) override;
 
    void simulate(bool clockSimulation, bool logicLUTFlag,
                  std::string cdcCollectionName = std::string(""),
                  std::string tsCollectionName = std::string(""));
 
    const TRGCDCSegmentHit* hit(const TRGCDCSegmentHit*);
 
    void addStoreHit(const CDCTriggerSegmentHit*);
 
  public:
 
    void simulateWithoutClock(bool logicLUTFlag);
 
    void simulateWithClock(std::string cdcCollectionName,
                           std::string tsCollectionName);
 
  private:
 
    TRGCDCLUT* m_TSLUT = nullptr;
 
//    const TRGCDCLUT * const _lut;  //Will be Removed.
 
    std::vector<const TRGCDCWire*> _wires;
 
    const TRGCDCWire* _center;
 
    TRGSignal _signal;
 
    std::vector<const TRGCDCWireHit*> _hits;
 
    std::vector<const CDCTriggerSegmentHit*> _storeHits;
 
    std::string m_TSLUTFileName;
 
    // Friends
    friend class TRGCDC;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  const std::vector<const TRGCDCWire*>&
  TRGCDCSegment::wires(void) const
  {
    return _wires;
  }
 
  inline
  const TRGCDCWire*
  TRGCDCSegment::operator[](unsigned id) const
  {
    if (id < _wires.size())
      return _wires[id];
    return 0;
  }
 
  inline
  const TRGSignal&
  TRGCDCSegment::signal(void) const
  {
    return _signal;
  }
 
  inline
  const TRGCDCSegmentHit*
  TRGCDCSegment::hit(const TRGCDCSegmentHit* h)
  {
    return (const TRGCDCSegmentHit*)
           TRGCDCCell::hit((const TRGCDCCellHit*) h);
  }
 
  inline
  const TRGCDCSegmentHit*
  TRGCDCSegment::hit(void) const
  {
    return (const TRGCDCSegmentHit*) TRGCDCCell::hit();
  }
 
  inline
  void
  TRGCDCSegment::addStoreHit(const CDCTriggerSegmentHit* h)
  {
    _storeHits.push_back(h);
  }
 
  inline
  const std::vector<const CDCTriggerSegmentHit*>
  TRGCDCSegment::storeHits(void) const
  {
    return _storeHits;
  }
 
  inline
  const TRGCDCLUT*
  TRGCDCSegment::LUT(void)  const
  {
    return m_TSLUT;
  }
 
  inline
  const TRGCDCWire&
  TRGCDCSegment::center(void) const
  {
    if (_wires.size() == 15)
      return * _wires[0];
    return * _wires[5];
  }
 
} // namespace Belle2
 
#endif /* TRGCDCSegment_FLAG_ */