DTSectColl.h

Go to the documentation of this file.

//-------------------------------------------------
//
//--------------------------------------------------
#ifndef DT_SECT_COLL_H
#define DT_SECT_COLL_H
 
//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
class DTTracoTrigData;
class DTSectCollCand;
class DTConfigSectColl;
class DTTrigGeom;
class DTChambPhSegm;
class DTChambThSegm;
class DTSectCollSegm;
class DTSC;
class DTTSPhi;
class DTTSTheta;
class DTSCTrigUnit;
 
//----------------------
// Base Class Headers --
//----------------------
#include "L1Trigger/DTUtilities/interface/DTCache.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollPhCand.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollThCand.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollPhSegm.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollThSegm.h"
#include "DataFormats/MuonDetId/interface/DTSectCollId.h"
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigManager.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
//---------------
// C++ Headers --
//---------------
#include <vector>
 
//              ---------------------
//              -- Class Interface --
//              ---------------------
 
typedef std::vector<DTSectCollPhSegm> DTSectCollPhVector;
typedef std::vector<DTSectCollThSegm> DTSectCollThVector;
typedef DTCache<DTSectCollPhSegm, DTSectCollPhVector> DTSCPhCache;
typedef DTCache<DTSectCollThSegm, DTSectCollThVector> DTSCThCache;
 
class DTSectColl : public DTSCPhCache, public DTSCThCache {
public:
  //DTSectColl(edm::ParameterSet& sc_pset);
  DTSectColl(DTSectCollId id);
 
  ~DTSectColl() override;
 
  void setConfig(const DTConfigManager* conf);
 
  inline DTTSPhi* getTSPhi(int istat) const { return _tsphi[istat - 1]; }
 
  inline DTTSTheta* getTSTheta(int istat) const { return _tstheta[istat - 1]; }
 
  inline const DTConfigSectColl* config() const { return _config; }
 
  // non-const methods
 
  /*   //! Add a TSM candidate to the Sect Coll, ifs is first/second track flag  */
  /*   void addCandPh(DTSectCollPhCand* cand);  */
 
  /*   //! Add a TS Theta candidate to the Sect Coll, ifs is first/second track flag  */
  /*   void addCandTh(DTSectCollThCand* cand); */
 
  /*    //! Set a flag to skip sort2 */
  /*    void ignoreSecondTrack() { _ignoreSecondTrack=1; } */
 
  void localClear();
 
  void loadSectColl();
 
  void addTSPhi(int step, const DTChambPhSegm* tsmsegm, int ifs, int istat);
 
  void addTSTheta(int step, const DTChambThSegm* tsmsegm, int istat);
 
  void addTU(DTSCTrigUnit* tru);
 
  DTSC* getDTSC(int step, int istat) const;
 
  void runSectColl();
 
  DTSectCollPhCand* getDTSectCollPhCand(int ifs, unsigned n) const;
 
  DTSectCollThCand* getDTSectCollThCand(unsigned n) const;
 
  // const methods
 
  DTSectCollPhCand* getTrackPh(int n) const;
 
  DTSectCollThCand* getTrackTh(int n) const;
 
  unsigned nCandPh(int ifs) const;
 
  unsigned nCandTh() const;
 
  int nSegmPh(int step);
 
  int nSegmTh(int step);
 
  inline int nTracksPh() const { return _outcand_ph.size(); }
 
  inline int nTracksTh() const { return _outcand_th.size(); }
 
  const DTSectCollPhSegm* SectCollPhSegment(int step, unsigned n);
 
  const DTSectCollThSegm* SectCollThSegment(int step);
 
  std::vector<DTSectCollPhSegm>::const_iterator beginPh() const { return DTSCPhCache::_cache.begin(); }
 
  int sizePh() const { return DTSCPhCache::_cache.size(); }
 
  std::vector<DTSectCollPhSegm>::const_iterator endPh() const { return DTSCPhCache::_cache.end(); }
 
  std::vector<DTSectCollThSegm>::const_iterator beginTh() const { return DTSCThCache::_cache.begin(); }
 
  int sizeTh() const { return DTSCThCache::_cache.size(); }
 
  std::vector<DTSectCollThSegm>::const_iterator endTh() const { return DTSCThCache::_cache.end(); }
 
  //  LocalPoint LocalPosition(const DTTrigData*) const;
 
  //  LocalVector LocalDirection(const DTTrigData*) const;
 
  void clearCache() {
    DTSCPhCache::clearCache();
    DTSCThCache::clearCache();
  }
 
  void reconstruct() override {
    loadSectColl();
    runSectColl();
  }
 
  DTSectCollId SectCollId() { return _sectcollid; }
 
private:
  // Configuration
  const DTConfigSectColl* _config;
 
  // SC Id
  DTSectCollId _sectcollid;
 
  DTTSPhi* _tsphi[DTConfigSectColl::NTSPSC];
  DTTSTheta* _tstheta[DTConfigSectColl::NTSTSC];
 
  // SM: new  sector collector
  DTSC* _tsc[DTConfigSectColl::NSTEPL - DTConfigSectColl::NSTEPF + 1][DTConfigSectColl::NDTSC];
 
  // input data Phi
  std::vector<DTSectCollPhCand*> _incand_ph[2];
 
  // output data Phi
  std::vector<DTSectCollPhCand*> _outcand_ph;
 
  // input data Theta
  std::vector<DTSectCollThCand*> _incand_th;
 
  // output data Theta
  std::vector<DTSectCollThCand*> _outcand_th;
};
#endif