Segment.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 a wire in CDC.
//-----------------------------------------------------------------------------
 
#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 TRGSignal& signal_adc(void) const override;

    const TRGCDCSegmentHit* hit(void) const;

    const std::vector<const CDCTriggerSegmentHit*> storeHits(void) const;

    unsigned hitPattern(void) const;
    unsigned hitPattern_adc(void) const;
    unsigned hitPattern(int clk0, int clk1) const;
    std::vector<float> hitPatternTime(void) 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,
                  const std::string& cdcCollectionName = std::string(""),
                  const 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;

    TRGSignal _signal_adc;

    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 TRGSignal&
  TRGCDCSegment::signal_adc(void) const
  {
    return _signal_adc;
  }
 
  inline
  const TRGCDCSegmentHit*
  TRGCDCSegment::hit(const TRGCDCSegmentHit* h)
  {
    //TODO only this strong retyping work, is it OK?
    return reinterpret_cast<const TRGCDCSegmentHit*>(TRGCDCCell::hit(reinterpret_cast<const TRGCDCCellHit*>(h)));
  }
 
  inline
  const TRGCDCSegmentHit*
  TRGCDCSegment::hit(void) const
  {
    //TODO only this strong retyping work, is it OK?
    return reinterpret_cast<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_ */