---

DTTrig.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: DTTrig
//
//   Description: Steering routine for L1 trigger simulation in
//                a muon barrel station
//
//
//   Author List:
//   C. Grandi
//   Modifications: 
//   S Vanini, S. Marcellini, D. Bonacorsi,  C.Battilana
//
//   07/03/30 : configuration now through DTConfigManager SV
//-------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "L1Trigger/DTTrigger/interface/DTTrig.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/ParameterSet/interface/InputTag.h"
#include "CalibMuon/DTDigiSync/interface/DTTTrigSyncFactory.h"
#include "CalibMuon/DTDigiSync/interface/DTTTrigBaseSync.h"

#include "Geometry/DTGeometry/interface/DTGeometry.h"
#include "Geometry/Records/interface/MuonGeometryRecord.h"
#include "Geometry/DTGeometry/interface/DTLayer.h"
#include "Geometry/DTGeometry/interface/DTChamber.h"
#include "CondFormats/DTObjects/interface/DTT0.h"
#include "CondFormats/DataRecord/interface/DTT0Rcd.h"
#include "CondFormats/DTObjects/interface/DTTtrig.h"
#include "CondFormats/DataRecord/interface/DTTtrigRcd.h"
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigManager.h"
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigManagerRcd.h"

//---------------
// C++ Headers --
//---------------
#include <iostream>
#include <string>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "Geometry/DTGeometry/interface/DTChamber.h"

//----------------
// Constructors --
//----------------

DTTrig::DTTrig(const  edm::ParameterSet &params) : 
  _configid(0) , _geomid(0) , _t0id(0) , _ttrigid(0) {

  // Set configuration parameters
  // _debug = _conf_manager->getDTTPGDebug();
  _debug = params.getUntrackedParameter<bool>("debug"); // CB FIXME: update when debug will be fully configured from parameter set

  if(_debug){
    std::cout << std::endl;
    std::cout << "**** Initialization of DTTrigger ****" << std::endl;
    std::cout << std::endl;
    std::cout << "DTTrig::DTTrig creating synchronizer" << std::endl;
  }

  _digitag   = params.getParameter<edm::InputTag>("digiTag");
  _digi_sync = DTTTrigSyncFactory::get()->create(params.getParameter<std::string>("tTrigMode"),
                                              params.getParameter<edm::ParameterSet>("tTrigModeConfig"));
  _usesyncdb = params.getParameter<std::string>("tTrigMode")!="DTTTrigSyncTOFCorr";
}


//--------------
// Destructor --
//--------------
DTTrig::~DTTrig(){

  clear();
  delete _digi_sync; //CB check if it is really needed

}

void 
DTTrig::createTUs(const edm::EventSetup& iSetup ){
  
  // build up Sector Collectors and then
  // build the trrigger units (one for each chamber)
  for(int iwh=-2;iwh<=2;iwh++){ 
    for(int ise=1;ise<=12;ise++){ 
      if(_debug){
        std::cout << "calling sectcollid wh sc " << iwh <<  " " << ise << std::endl;}
      DTSectCollId scid(iwh,ise);
      SC_iterator it =  _cache1.find(scid);
      if ( it != _cache1.end()) {
        std::cout << "DTTrig::createTUs: Sector Collector unit already exists"<<std::endl;
        continue;
      }    
      // add a sector collector to the map
      // SCConf_iterator scit = _scconf.find(scid);
      //edm::ParameterSet sc_pset = _conf_pset.getParameter<edm::ParameterSet>("SectCollParameters");
      DTSectColl* sc;
      //sc = new DTSectColl(sc_pset);
      sc = new DTSectColl(scid);

      //  if ( scit != _scconf.end()){
      //        sc = new DTSectColl( (*scit).second);
      //       }
      //       else {
      //        std::cout << "DTTrig::createTUs: SC config file does not exist. Using default one";
      //        sc = new DTSectColl(config());
      //       }
      if(_debug){
        std::cout << " DTTrig::createTUs new SC sc = " << sc  
                  << " at scid.sector() " << scid.sector() 
                  << " at scid.wheel() " << scid.wheel()   
                  << std::endl;
      }
      _cache1[scid] = sc;  
    }
  }
  
  edm::ESHandle<DTGeometry>pDD;
  iSetup.get<MuonGeometryRecord>().get(pDD);
  for (std::vector<DTChamber*>::const_iterator ich=pDD->chambers().begin(); ich!=pDD->chambers().end();ich++){
       
    DTChamber* chamb = (*ich);
    DTChamberId chid = chamb->id();
    TU_iterator it = _cache.find(chid);
    if ( it != _cache.end()) {
      std::cout << "DTTrig::init: Trigger unit already exists" << std::endl;
      continue;
    }    
    //    Conf_iterator cit = _truconf.find(chid);
    //       if ( cit == _truconf.end()) {
    //  std::cout << "DTTrig::init: Local Config File not found using default config" << std::endl;
    //  DTSCTrigUnit* tru = new DTSCTrigUnit(chamb,config());
    //  _cache[chid] = tru;
    //  continue;
    //       }

    // add a trigger unit to the map with a link to the station
    //edm::ParameterSet tu_pset = _conf_pset.getParameter<edm::ParameterSet>("TUParameters");
    //DTSCTrigUnit* tru = new DTSCTrigUnit(chamb,tu_pset);
    DTSCTrigUnit* tru = new DTSCTrigUnit(chamb,_digi_sync);
    _cache[chid] = tru;
    
    //----------- add TU to corresponding SC
    // returning correspondent SC id
    DTSectCollId scid;
    if(chid.sector()==13) { 
      scid = DTSectCollId(chid.wheel(), 4);}
    else if(chid.sector()==14)  {
      scid = DTSectCollId(chid.wheel(), 10);}
    else  { 
      scid = DTSectCollId(chid.wheel(), chid.sector() );}
    
    SC_iterator it1 =  _cache1.find(scid);
    
    if ( it1 != _cache1.end()) {
      
      DTSectColl* sc = (*it1).second;
      if(_debug) {
        std::cout << "DTTrig::init:  adding TU in SC << " 
                  << " sector = " << scid.sector() 
                  << " wheel = " << scid.wheel() 
                  << std::endl;}
      sc->addTU(tru);    
    }
    else {
      std::cout << "DTTrig::createTUs: Trigger Unit not in the map: ";
    }
    
  }

}


void 
DTTrig::triggerReco(const edm::Event& iEvent, const edm::EventSetup& iSetup) {

  updateES(iSetup);

  DTDigiMap digiMap;
  //Sort digis by chamber so they can be used by BTIs
  edm::Handle<DTDigiCollection> dtDigis;
  iEvent.getByLabel(_digitag, dtDigis);   
  DTDigiCollection::DigiRangeIterator detUnitIt;
  
  for (detUnitIt=dtDigis->begin();
       detUnitIt!=dtDigis->end();
       ++detUnitIt){
    const DTLayerId& layId = (*detUnitIt).first;
    const DTChamberId chambId=layId.superlayerId().chamberId();
    const DTDigiCollection::Range& range = (*detUnitIt).second;
    //    DTDigiCollection tmpDTDigiColl;
    //tmpDTDigiColl.put(range,layId); 
    digiMap[chambId].put(range,layId); 
//     const DTDigiCollection::Range& range = (*detUnitIt).second;
//     for (DTDigiCollection::const_iterator digiIt = range.first;
//       digiIt!=range.second;
//       ++digiIt){
//       DTDigiCollection tmp;
      
//       digiMap[chambId].push_back((*digiIt));
//     }
  }

  // CB the commented because we don't use config()->debug() anymore in future will probably be possible to avoid the digis sorting  
//   if(config()->debug()>2){
//     std::cout << "----------DTDigis ordered by chamber:" << std::endl;
//     for (DTDigiMap_const_iterator digiMapIt=digiMap.begin();
//       digiMapIt!=digiMap.end();
//       digiMapIt++){
//       DTChamberId chambId = (*digiMapIt).first;
//       DTDigiCollection digis = (*digiMapIt).second;
//       std::cout << "Chamber id   " << chambId << std::endl;
//       DTDigiCollection::DigiRangeIterator RangeIt;
//       for (RangeIt=digis.begin();
//         RangeIt!=digis.end();
//         RangeIt++){
//      std::cout << "Digi's layer   " << (*RangeIt).first << std::endl;
//      const DTDigiCollection::Range& range = (*RangeIt).second;
//      for (DTDigiCollection::const_iterator digiIt = range.first;
//           digiIt!=range.second;
//           ++digiIt){
//        std::cout << "Digi's data   " << (*digiIt) << std::endl; 
//      }
        
        
//       }
//     }
//   }
  
  //Run reconstruct for single trigger subsystem (Bti, Traco TS)
  for (TU_iterator it=_cache.begin();it!=_cache.end();it++){
    DTSCTrigUnit* thisTU=(*it).second;
    if (thisTU->BtiTrigs()->size()>0){
      thisTU->BtiTrigs()->clearCache();
      thisTU->TSThTrigs()->clearCache();
      thisTU->TracoTrigs()->clearCache();
      thisTU->TSPhTrigs()->clearCache();
    }
    DTChamberId chid=thisTU->statId();
    DTDigiMap_iterator dmit = digiMap.find(chid);
    if (dmit !=digiMap.end()){
      thisTU->BtiTrigs()->reconstruct((*dmit).second); 
      if(thisTU->BtiTrigs()->size()>0){
        thisTU->TSThTrigs()->reconstruct();
        thisTU->TracoTrigs()->reconstruct();
        if(thisTU->TracoTrigs()->size()>0)
          thisTU->TSPhTrigs()->reconstruct();
      }
    }
  }
  //Run reconstruct for Sector Collector
  for (SC_iterator it=_cache1.begin();it!=_cache1.end();it++){
    DTSectColl* sectcoll = (*it).second;
    DTSectCollId scid = (*it).first;
    if (sectcoll->sizePh()>0 || sectcoll->sizeTh()>0)
      sectcoll->clearCache();
    bool mustreco = false;
    for (int i=1;i<5;i++) {
      if (sectcoll->getTSPhi(i)->size()>0) {
        mustreco = true;
        break;
      }
    }
    for (int i=1;i<4;i++) {
      if (sectcoll->getTSTheta(i)->size()>0) {
        mustreco = true;
        break;
      }
    }
    if (scid.sector()==4 || scid.sector()==10){
      if (sectcoll->getTSPhi(5)->size()>0)
        mustreco = true;
    }
    if (mustreco)
      sectcoll->reconstruct();
  }

}

void
DTTrig::updateES(const edm::EventSetup& iSetup){

  // Check for updatets in config
  edm::ESHandle<DTConfigManager> confHandle;
  edm::ESHandle<DTGeometry> geomHandle;
  edm::ESHandle<DTT0> t0Handle;
  edm::ESHandle<DTTtrig> ttrigHandle;

  if (iSetup.get<DTConfigManagerRcd>().cacheIdentifier()!=_configid) {
    
    if (_debug)
    std::cout << "DTTrig::updateES updating DTTPG configuration" << std::endl;
    
    _configid = iSetup.get<DTConfigManagerRcd>().cacheIdentifier();
    iSetup.get<DTConfigManagerRcd>().get(confHandle);
    _conf_manager = confHandle.product();
    for (TU_iterator it=_cache.begin();it!=_cache.end();it++){
      (*it).second->setConfig(_conf_manager);
    }
    for (SC_iterator it=_cache1.begin();it!=_cache1.end();it++){
    (*it).second->setConfig(_conf_manager);
    }

  }

  if (iSetup.get<MuonGeometryRecord>().cacheIdentifier()!=_configid) {

    if (_debug)
    std::cout << "DTTrig::updateES updating muon geometry" << std::endl;

    _geomid = iSetup.get<MuonGeometryRecord>().cacheIdentifier();
    iSetup.get<MuonGeometryRecord>().get(geomHandle);
    for (TU_iterator it=_cache.begin();it!=_cache.end();it++){
      (*it).second->setGeom(geomHandle->chamber((*it).second->statId()));
    }

  }

  if (_usesyncdb &&
      (iSetup.get<DTT0Rcd>().cacheIdentifier()!=_t0id || 
      iSetup.get<DTTtrigRcd>().cacheIdentifier()!=_ttrigid)) {

    if (_debug)
    std::cout << "DTTrig::updateES updating synchronizer" << std::endl;

    _t0id    = iSetup.get<DTT0Rcd>().cacheIdentifier();
    _ttrigid = iSetup.get<DTTtrigRcd>().cacheIdentifier();
    _digi_sync->setES(iSetup);

  }

} 


void
DTTrig::clear() {
  // Delete the map
  for (TU_iterator it=_cache.begin();it!=_cache.end();it++){
    // Delete all the trigger units 
    delete (*it).second;
  }
  _cache.clear(); 

  for (SC_iterator it=_cache1.begin();it!=_cache1.end();it++){
    // Delete all the Sector Collectors
    delete (*it).second;
  }
  _cache1.clear();

}

DTSCTrigUnit*
DTTrig::trigUnit(DTChamberId chid) {
  /*check();*/  return constTrigUnit(chid);

}



DTSCTrigUnit*
DTTrig::constTrigUnit(DTChamberId chid) const {
//    std::cout << " SC: running DTTrig::constTrigUnit(DTChamberId chid)" << std::endl;
  TU_const_iterator it = _cache.find(chid);
  if ( it == _cache.end()) {
    std::cout << "DTTrig::trigUnit: Trigger Unit not in the map: ";
    std::cout << " wheel=" << chid.wheel() ;
    std::cout << ", station=" << chid.station();
    std::cout << ", sector=" << chid.sector();
    std::cout << std::endl;
    return 0;
  }

  return (*it).second;
}

DTSectColl*
DTTrig::SCUnit(DTSectCollId scid) const {
SC_const_iterator it = _cache1.find(scid);
  if ( it == _cache1.end()) {
    std::cout << "DTTrig::SCUnit: Trigger Unit not in the map: ";
    std::cout << " wheel=" << scid.wheel() ;
    std::cout << ", sector=" << scid.sector();
    std::cout << std::endl;
    return 0;
  }

  return (*it).second;
}

DTSCTrigUnit*
DTTrig::trigUnit(int wheel, int stat, int sect) {
  return constTrigUnit(wheel, stat, sect);
}

DTSectColl*
DTTrig::SCUnit(int wheel, int sect) const {
  sect++;
  return SCUnit(DTSectCollId(wheel,sect));
}


DTSCTrigUnit*
DTTrig::constTrigUnit(int wheel, int stat, int sect) const {
  sect++;   // offset 1 for sector number ([0,11] --> [1,12])
  return constTrigUnit(DTChamberId(wheel,stat,sect));

}


DTChambPhSegm* 
DTTrig::chPhiSegm1(DTSCTrigUnit* unit, int step) {
  if(unit==0)return 0;
  if(unit->nPhiSegm(step)<1)return 0;
  return const_cast<DTChambPhSegm*>(unit->phiSegment(step,1));
}

DTChambPhSegm* 
DTTrig::chPhiSegm2(DTSCTrigUnit* unit, int step) {
  if(unit==0)return 0;
  if(unit->nPhiSegm(step)<2)return 0;
  return const_cast<DTChambPhSegm*>(unit->phiSegment(step,2));
}

DTChambThSegm* 
DTTrig::chThetaSegm(DTSCTrigUnit* unit, int step) {
  if(unit==0)return 0;
  if(unit->nThetaSegm(step)<1)return 0;
  return const_cast<DTChambThSegm*>(unit->thetaSegment(step,1));
}

DTChambPhSegm* 
DTTrig::chPhiSegm1(DTChamberId sid, int step) {
  return chPhiSegm1(trigUnit(sid),step);
}

DTChambPhSegm* 
DTTrig::chPhiSegm2(DTChamberId sid, int step) {
  return chPhiSegm2(trigUnit(sid),step);
}

DTChambThSegm* 
DTTrig::chThetaSegm(DTChamberId sid, int step) {
  if(sid.station()==4)return 0;
  return chThetaSegm(trigUnit(sid),step);
}

DTChambPhSegm*
DTTrig::chPhiSegm1(int wheel, int stat, int sect, int step) {
   return chPhiSegm1(trigUnit(wheel,stat,sect),step);
  // to make it transparent to the outside world
  //  return chSectCollSegm1(wheel,stat,sect,step);

}

DTChambPhSegm* 
DTTrig::chPhiSegm2(int wheel, int stat, int sect, int step) {
  //  if(stat==4&&(sect==3||sect==9)) {
  // if hrizontal chambers of MB4 get first track of twin chamber (flag=1)
  //   return chPhiSegm1(trigUnit(wheel,stat,sect,1),step);
  //  } else {
    return chPhiSegm2(trigUnit(wheel,stat,sect),step);
  // to make it transparent to the outside world
  // return chSectCollSegm2(wheel,stat,sect,step);
  //}
}

DTChambThSegm* 
DTTrig::chThetaSegm(int wheel, int stat, int sect, int step) {
  if(stat==4)return 0;
  return chThetaSegm(trigUnit(wheel,stat,sect),step);
}

// SM sector collector section
DTSectCollPhSegm* 
DTTrig::chSectCollPhSegm1(DTSectColl* unit, int step) {

  if(unit==0)return 0;
   if(unit->nSegmPh(step)<1)return 0;
   return const_cast<DTSectCollPhSegm*>(unit->SectCollPhSegment(step,1));
}

DTSectCollPhSegm* 
DTTrig::chSectCollPhSegm2(DTSectColl* unit, int step) {
  if(unit==0)return 0;
    if(unit->nSegmPh(step)<2)return 0;
  return const_cast<DTSectCollPhSegm*>(unit->SectCollPhSegment(step,2));
}


DTSectCollPhSegm*
DTTrig::chSectCollPhSegm1(int wheel, int sect, int step) {

  return chSectCollPhSegm1(SCUnit(wheel,sect),step);
}

DTSectCollPhSegm* 
DTTrig::chSectCollPhSegm2(int wheel, int sect, int step) {
  //  if(stat==4&&(sect==3||sect==9)) {
    // if hrizontal chambers of MB4 get first track of twin chamber (flag=1)
  //return chSectCollSegm1(trigUnit(wheel,stat,sect,1),step);
  //} else {
    return chSectCollPhSegm2(SCUnit(wheel,sect),step);
    //}
}

DTSectCollThSegm* 
DTTrig::chSectCollThSegm(DTSectColl* unit, int step) {

  if(unit==0)return 0;
   if(unit->nSegmTh(step)<1)return 0;
  return const_cast<DTSectCollThSegm*>(unit->SectCollThSegment(step));
}

DTSectCollThSegm*
DTTrig::chSectCollThSegm(int wheel, int sect, int step) {

  return chSectCollThSegm(SCUnit(wheel,sect),step);
}

  // end SM


void 
DTTrig::dumpGeom() {
  /*check();*/
  for (TU_const_iterator it=_cache.begin();it!=_cache.end();it++){
    ((*it).second)->dumpGeom();
  }
}

std::vector<DTBtiTrigData> 
DTTrig::BtiTrigs() {
  /*check();*/
  std::vector<DTBtiTrigData> trigs;
  TU_iterator ptu;
  for(ptu=_cache.begin();ptu!=_cache.end();ptu++) {
    DTSCTrigUnit* tu = (*ptu).second;
    std::vector<DTBtiTrigData>::const_iterator p; //p=0;
    std::vector<DTBtiTrigData>::const_iterator peb=tu->BtiTrigs()->end();
    for(p=tu->BtiTrigs()->begin();p!=peb;p++){
      trigs.push_back(*p);
    }
  }
  return trigs;
}

std::vector<DTTracoTrigData> 
DTTrig::TracoTrigs()  {
  std::vector<DTTracoTrigData> trigs;
  TU_iterator ptu;
  /*check();*/
  for(ptu=_cache.begin();ptu!=_cache.end();ptu++) {
    DTSCTrigUnit* tu = (*ptu).second;
    std::vector<DTTracoTrigData>::const_iterator p; //p=0;
    std::vector<DTTracoTrigData>::const_iterator peb=tu->TracoTrigs()->end();
    for(p=tu->TracoTrigs()->begin();p!=peb;p++){
      trigs.push_back(*p);
    }
  }
  return trigs;
}

std::vector<DTChambPhSegm> 
DTTrig::TSPhTrigs()  {
  /*check();*/
  std::vector<DTChambPhSegm> trigs;
  TU_iterator ptu;
  for(ptu=_cache.begin();ptu!=_cache.end();ptu++) {
    DTSCTrigUnit* tu = (*ptu).second;
    std::vector<DTChambPhSegm>::const_iterator p; //p=0;
    std::vector<DTChambPhSegm>::const_iterator peb=tu->TSPhTrigs()->end();
    for(p=tu->TSPhTrigs()->begin();p!=peb;p++){
      trigs.push_back(*p);
    }
  }
  return trigs;
}

std::vector<DTChambThSegm> 
DTTrig::TSThTrigs()  {
  /*check();*/
  std::vector<DTChambThSegm> trigs;
  TU_iterator ptu;
  for(ptu=_cache.begin();ptu!=_cache.end();ptu++) {
    DTSCTrigUnit* tu = (*ptu).second;
    std::vector<DTChambThSegm>::const_iterator p; //p=0;
    std::vector<DTChambThSegm>::const_iterator peb=tu->TSThTrigs()->end();
    for(p=tu->TSThTrigs()->begin();p!=peb;p++){
      trigs.push_back(*p);
    }
  }
  return trigs;
}

std::vector<DTSectCollPhSegm> 
DTTrig::SCPhTrigs()  {
  /*check();*/
  std::vector<DTSectCollPhSegm> trigs;
  //  SC_iterator ptu;
  SC_iterator psc;
  for(psc=_cache1.begin();psc!=_cache1.end();psc++) {
    //    DTSCTrigUnit* tu = (*ptu).second;
    //
    // old SMDB:    
    //      DTSectColl* tu = (*ptu).second;
    //      std::vector<DTChambPhSegm>::const_iterator p=0;
    //      std::vector<DTChambPhSegm>::const_iterator peb=tu->SCTrigs()->end();
    //      for(p=tu->SCTrigs()->begin();p!=peb;p++){
    //        trigs.push_back(*p);
    //      } 

    DTSectColl* sc = (*psc).second;
    std::vector<DTSectCollPhSegm>::const_iterator p;
    std::vector<DTSectCollPhSegm>::const_iterator peb=sc->endPh();
    for(p=sc->beginPh();p!=peb;p++){
      trigs.push_back(*p);
    }

  }
  return trigs;
}


std::vector<DTSectCollThSegm> 
DTTrig::SCThTrigs()  {
  /*check();*/
  std::vector<DTSectCollThSegm> trigs;
  SC_iterator psc;
  for(psc=_cache1.begin();psc!=_cache1.end();psc++) {
    DTSectColl* sc = (*psc).second;
    std::vector<DTSectCollThSegm>::const_iterator p; //p=0;
    std::vector<DTSectCollThSegm>::const_iterator peb=sc->endTh();
    for(p=sc->beginTh();p!=peb;p++){
      trigs.push_back(*p);
    }

  }
  return trigs;
}

---