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() { return  DTSCPhCache::_cache.begin(); }

  int sizePh() { return DTSCPhCache::_cache.size(); } 

  std::vector<DTSectCollPhSegm>::const_iterator endPh() { return DTSCPhCache::_cache.end(); } 
  
  std::vector<DTSectCollThSegm>::const_iterator beginTh() { return DTSCThCache::_cache.begin(); }
  
  int sizeTh() { return DTSCThCache::_cache.size(); }

  std::vector<DTSectCollThSegm>::const_iterator endTh() { 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