DTSC.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: DTSC.cpp
//
//   Description: Implementation of DTSectColl trigger algorithm
//
//
//   Author List:
//   S. Marcellini
//   Modifications: 
//   11/11/06 C. Battilana : theta cand added
//   12/12/06 C. Battilana : _stat added
//   09/01/07 C. Battilana : updated to local conf
//
//
//--------------------------------------------------


//-----------------------
// This Class's Header --
//-----------------------
#include "L1Trigger/DTSectorCollector/interface/DTSC.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigSectColl.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectColl.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollPhCand.h"
#include "L1Trigger/DTSectorCollector/interface/DTSectCollThCand.h"

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

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

DTSC::DTSC(int istat) : _ignoreSecondTrack(0) ,_stat(istat){

  // reserve the appropriate amount of space for vectors
  // test _incand[0].reserve(DTConfigSectColl::NTSMSC);
  // test_incand[1].reserve(DTConfigSectColl::NTSMSC);
  // test _outcand.reserve(2);
 
}


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

  clear();

}


//--------------
// Operations --
//--------------

void
DTSC::clear() {

  _ignoreSecondTrack=0;

  for(int itk=0;itk<=1;itk++){
 
    _incand_ph[itk].clear();
  }

  _outcand_ph.clear();
  _cand_th.clear();

}


// 
void
DTSC::run() {

  if(config()->debug()){
    std::cout << "DTSC::run: Processing DTSectColl: ";
    std::cout << nFirstTPh() << " first & " << nSecondTPh() << " second Phi tracks ";
    std::cout << " - "<< nCandTh() << " Theta tracks" << std::endl;
  
  }

  if(nFirstTPh()<1)return; // skip if no first tracks
  //
  // SORT 1
  //

  // debugging
    if(config()->debug()){
     std::cout << "Vector of first Phi tracks in DTSectColl: " << std::endl;
    std::vector<DTSectCollPhCand*>::const_iterator p;
    for(p=_incand_ph[0].begin(); p!=_incand_ph[0].end(); p++) {
           (*p)->print();
    }
   }
  // end debugging
 
  DTSectCollPhCand* first=DTSectCollsort1();
  if(config()->debug()){
    std::cout << "SC: DTSC::run: first Phi track is = " << first << std::endl;
  }
  if(first!=nullptr) {
    _outcand_ph.push_back(first); 

  }
  if(nSecondTPh()<1)return; // skip if no second tracks

  //
  // SORT 2
  //

  // debugging
  if(config()->debug()){
    std::vector<DTSectCollPhCand*>::const_iterator p;
    std::cout << "Vector of second Phi tracks in DTSectColl: " << std::endl;
    for(p=_incand_ph[1].begin(); p!=_incand_ph[1].end(); p++) {
       (*p)->print();
    }
  }
  // end debugging

  DTSectCollPhCand* second=DTSectCollsort2();
  if(second!=nullptr) {
    _outcand_ph.push_back(second); 
  }
  
}


DTSectCollPhCand*
DTSC::DTSectCollsort1() {

  // Do a sort 1
  DTSectCollPhCand* best=nullptr;
  DTSectCollPhCand* carry=nullptr;
  std::vector<DTSectCollPhCand*>::iterator p;
  for(p=_incand_ph[0].begin(); p!=_incand_ph[0].end(); p++) {
    DTSectCollPhCand* curr=(*p);

    curr->setBitsSectColl();    // SM sector collector set bits in dataword to make SC sorting
    
    // NO Carry in Sector Collector sorting in default 
    if(config()->SCGetCarryFlag(_stat)) {  // get carry

      if(best==nullptr){
    best=curr;
      } 
      else if((*curr)<(*best)){
    carry=best;
    best=curr;
      } 
      else if(carry==nullptr){
    carry=curr;
      } 
      else if((*curr)<(*carry)){
    carry=curr;
      } 

    }
    else if(config()->SCGetCarryFlag(_stat)==0){ // no carry (default)
      if(best==nullptr){
    best=curr;
      } 
      else if((*curr)<(*best)){
    
    best=curr;
      } 
      
    }
    
    if(carry!=nullptr && config()->SCGetCarryFlag(_stat)) { // reassign carry to sort 2 candidates
      carry->setSecondTrack(); // change value of 1st/2nd track bit
      _incand_ph[1].push_back(carry); // add to list of 2nd track
 
    }
  } 
  
  return best;

}


DTSectCollPhCand*
DTSC::DTSectCollsort2() {

  // Check if there are second tracks

  if(nTracksPh()<1){
    std::cout << "DTSC::DTSectCollsort2: called with no first Phi track.";
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }
  // If a first track at the following BX is present, ignore second tracks of any kind
  if(_ignoreSecondTrack){

    for(std::vector<DTSectCollPhCand*>::iterator p=_incand_ph[1].begin(); p!=_incand_ph[1].end(); p++) {

    }
    return nullptr;
  }

  // If no first tracks at the following BX, do a sort 2
  //  DTSectCollCand* best=getTrack(1);  ! not needed as lons as there is no comparison with best in sort 2
  DTSectCollPhCand* second=nullptr;
  std::vector<DTSectCollPhCand*>::iterator p;
  for(p=_incand_ph[1].begin(); p!=_incand_ph[1].end(); p++) {
    DTSectCollPhCand* curr=(*p);
    curr->setBitsSectColl();    // SM sector collector set bits in dataword to make SC sorting
    
    if(second==nullptr){
      second=curr;
    } 
    else if((*curr)<(*second)){
      second=curr;
    } 
    
  }

  return second;

}


void
DTSC::addPhCand(DTSectCollPhCand* cand) {

  _incand_ph[(1-cand->isFirst())].push_back(cand); 

}

void
DTSC::addThCand(DTSectCollThCand* cand) {

  _cand_th.push_back(cand); 

}


unsigned
DTSC::nCandPh(int ifs) const {

  if(ifs<1||ifs>2){
    std::cout << "DTSC::nCandPh: wrong track number: " << ifs;
    std::cout << " 0 returned!" << std::endl;
    return 0;
  }
  return _incand_ph[ifs-1].size();

}

unsigned
DTSC::nCandTh() const {

  return _cand_th.size();

}


DTSectCollPhCand*
DTSC::getDTSectCollPhCand(int ifs, unsigned n) const {

  if(ifs<1||ifs>2){
    std::cout << "DTSC::getDTSectCollPhCand: wrong track number: " << ifs;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }
  if(n<1 || n>nCandPh(ifs)) {
    std::cout << "DTSC::getDTSectCollPhCand: requested trigger not present: " << n;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }

  std::vector<DTSectCollPhCand*>::const_iterator p = _incand_ph[ifs-1].begin()+n-1;
  return (*p);

}

DTSectCollThCand*
DTSC::getDTSectCollThCand(unsigned n) const {

  if(n<1 || n>nCandTh()) {
    std::cout << "DTSC::getDTSectCollThCand: requested trigger not present: " << n;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }

  std::vector<DTSectCollThCand*>::const_iterator p = _cand_th.begin()+n-1;
  return (*p);

}

void
DTSC::addDTSectCollPhCand(DTSectCollPhCand* cand) {

  int ifs = (cand->isFirst()) ? 0 : 1;
 
  _incand_ph[ifs].push_back(cand); 

}

DTSectCollPhCand*
DTSC::getTrackPh(int n) const {

  if(n<1 || n>nTracksPh()) {
    std::cout << "DTSC::getTrackPh: requested track not present: " << n;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }

  std::vector<DTSectCollPhCand*>::const_iterator p = _outcand_ph.begin()+n-1;

  return (*p);

}


DTSectCollThCand*
DTSC::getTrackTh(int n) const {

  if(n<1 || n>nTracksTh()) {
    std::cout << "DTSC::getTrackTh: requested track not present: " << n;
    std::cout << " empty pointer returned!" << std::endl;
    return nullptr;
  }

  std::vector<DTSectCollThCand*>::const_iterator p = _cand_th.begin()+n-1;

  return (*p);

}