DTConfigTSPhi.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: DTConfigSectColl
//
//   Description: Configurable parameters and constants 
//   for Level1 Mu DT Trigger - TS Phi
//
//
//   Author List:
//   C. Battilana
//
//-----------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigTSPhi.h"

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

#include "FWCore/MessageLogger/interface/MessageLogger.h"

//----------------
// Constructors --
//----------------
DTConfigTSPhi::DTConfigTSPhi(const edm::ParameterSet& ps) { 

  setDefaults(ps);
  if (debug()) print();
}

DTConfigTSPhi::DTConfigTSPhi(bool debugTS, unsigned short int tss_buffer[7][31], int ntss, unsigned short int tsm_buffer[9]) { 

  m_ntss = 0;
  m_ntsm = 0;

  if (ntss == 0)
    return;

  m_debug = debugTS;

  bool tstren[24];
  bool tsscgs2, tsscgs1, tsscce1, tsshte1, tssnoe1, carrytss; 
  bool tsscce2, tsshte2, tssnoe2, tssccec, tsshtec, tssnoec;
  unsigned short  tssgs1, tssgs2, tssmsk1, tssmsk2;

  tsscgs2 = tsscgs1 = tsscce1 = tsshte1 = tssnoe1 = carrytss = false;
  tsscce2 = tsshte2 = tssnoe2 = tssccec = tsshtec = tssnoec  = false;
  tssgs1 = tssgs2 = tssmsk1 = tssmsk2 = 0;

  memset(tstren,true,24*sizeof(bool));

  // TSS unpacking
  for (int itss=0; itss<ntss; itss++) {     
    unsigned short int memory_tss[27];

    for(int ts=0;ts<27;ts++){
      memory_tss[ts] = tss_buffer[itss][ts+4];
      //std::cout << std::hex << memory_tss[ts] << " ";
    }
      
    tstren[itss*4]   = !(memory_tss[1]&0x08);
    tstren[itss*4+1] = !(memory_tss[1]&0x80);
    tstren[itss*4+2] = !(memory_tss[2]&0x08);
    tstren[itss*4+3] = !(memory_tss[2]&0x80);

    if(!itss) {
      tsscgs2 = !(memory_tss[0]&0x08);
      tssgs2  = memory_tss[0]&0x04 ? 0 : 1;
      tsscgs1 = !(memory_tss[0]&0x02);
      tssgs1  = memory_tss[0]&0x01 ? 0 : 1;
      tsscce1 = !(memory_tss[4]&0x04); 
      tsshte1 = !(memory_tss[4]&0x02); 
      tssnoe1 = !(memory_tss[4]&0x01);
      tsscce2 = !(memory_tss[3]&0x40); 
      tsshte2 = !(memory_tss[3]&0x20); 
      tssnoe2 = !(memory_tss[3]&0x10); 
      tssccec = !(memory_tss[3]&0x04); 
      tsshtec = !(memory_tss[3]&0x02); 
      tssnoec = !(memory_tss[3]&0x01);
      carrytss= !(memory_tss[4]&0x40);
      tssmsk1  = memory_tss[4]&0x10 ? 132 : 312;
      tssmsk2  = memory_tss[4]&0x20 ? 132 : 312;
    }
    
    m_ntss++;

  }

  // TSM unpacking
  unsigned short int memory_tsms[2], memory_tsmdu[2], memory_tsmdd[2];

  for(int ts=0;ts<2;ts++){
    memory_tsms[ts]  = tsm_buffer[ts+3];
    memory_tsmdu[ts] = tsm_buffer[ts+5];
    memory_tsmdd[ts] = tsm_buffer[ts+7];
    //std::cout << std::hex << memory_tsms[ts] << " " 
    //<< memory_tsmdu[ts] << " " << memory_tsmdd[ts] << " " << std::endl;
  }

  bool tsmcgs1 = true;
  unsigned short  tsmgs1  = memory_tsms[1]&0x02 ? 0 : 1;
  bool tsmcgs2 = true;
  unsigned short  tsmgs2  = 1;
  bool tsmcce1 = true; 
  bool tsmhte1 = true;  
  bool tsmnoe1 = true; 
  bool tsmcce2 = true; 
  bool tsmhte2 = true; 
  bool tsmnoe2 = true;
  bool tsmccec = true; 
  bool tsmhtec = true; 
  bool tsmnoec = true;
  bool carrytsms = !(memory_tsms[1]&0x01);
  unsigned short tsmmsk1  = memory_tsms[1]&0x08 ? 321 : 312;
  unsigned short tsmmsk2  = tsmmsk1;
  bool tsmword[8];
  tsmword[0] = !((memory_tsmdu[0]&0x80)&&(memory_tsmdd[0]&0x80)); 
  tsmword[1] = !(memory_tsms[0]&0x01); 
  tsmword[2] = !(memory_tsms[0]&0x02);
  tsmword[3] = !(memory_tsms[0]&0x04);
  tsmword[4] = !(memory_tsms[0]&0x08); 
  tsmword[5] = !(memory_tsms[0]&0x10);
  tsmword[6] = !(memory_tsms[0]&0x20); 
  tsmword[7] = !(memory_tsms[0]&0x40); 
  bool carrytsmd = !((memory_tsmdu[0]&0x10)&&(memory_tsmdd[0]&0x10));
    
  unsigned short tsmhsp = carrytss && carrytsms && carrytsmd;

  m_ntsm++;

  if (debug()) {
    std::cout << "TSS :" << std::dec << std::endl << "tstren= " ;
    for (int i=0; i<24 ;i++) std::cout << tstren[i] << " ";
    std::cout << " tsscgs1="  << tsscgs1
          << " tssgs1="   << tssgs1
          << " tsscgs2="  << tsscgs2
          << " tssgs2="   << tssgs2
          << " tsscce1="  << tsscce1
          << " tsshte1="  << tsshte1
          << " tssnoe1="  << tssnoe1
          << " tsscce2="  << tsscce2
          << " tsshte2="  << tsshte2
          << " tssnoe2="  << tssnoe2
          << " tssccec="  << tssccec
          << " tsshtec="  << tsshtec
          << " tssnoec="  << tssnoec
          << " carrytss=" << carrytss
          << " tssmsk1="  << tssmsk1
          << " tssmsk2="  << tssmsk2 << std::endl;

    std::cout << "TSM : "<< std::endl
          << "tsmcgs1="  << tsmcgs1
          << " tsmgs1="   << tsmgs1
          << " tsmcgs2="  << tsmcgs2
          << " tsmgs2="   << tsmgs2
          << " tsmcce1="  << tsmcce1
          << " tsmhte1="  << tsmhte1
          << " tsmnoe1="  << tsmnoe1
          << " tsmcce2="  << tsmcce2
          << " tsmhte2="  << tsmhte2
          << " tsmnoe2="  << tsmnoe2
          << " tsmccec="  << tsmccec
          << " tsmhtec="  << tsmhtec
          << " tsmnoec="  << tsmnoec
          << " tsmhsp=" << tsmhsp
          << " carrytsms=" << carrytsms
          << " carrytsmd=" << carrytsmd
          << " tsmword="; 
    for (int i=0;i<8;i++) std::cout << tsmword[i] << " ";
    std::cout << " tsmmsk1="  << tsmmsk1
          << " tsmmsk2="  << tsmmsk2 << std::endl;
  }

  setTssMasking(tssmsk1,1);
  setTssMasking(tssmsk2,2);
  setTssHtrigEna(tsshte1,1);
  setTssHtrigEna(tsshte2,2);
  setTssHtrigEnaCarry(tsshtec);
  setTssInOutEna(tssnoe1,1);
  setTssInOutEna(tssnoe2,2);
  setTssInOutEnaCarry(tssnoec);
  setTssCorrEna(tsscce1,1);
  setTssCorrEna(tsscce2,2);
  setTssCorrEnaCarry(tssccec);
  setTssGhost1Flag(tssgs1);
  setTssGhost2Flag(tssgs2);
  setTssGhost1Corr(tsscgs1);
  setTssGhost2Corr(tsscgs2);

  setTsmMasking(tsmmsk1,1);
  setTsmMasking(tsmmsk2,2);
  setTsmHtrigEna(tsmhte1,1);
  setTsmHtrigEna(tsmhte2,2);
  setTsmHtrigEnaCarry(tsmhtec);
  setTsmInOutEna(tsmnoe1,1);
  setTsmInOutEna(tsmnoe2,2);
  setTsmInOutEnaCarry(tsmnoec);
  setTsmCorrEna(tsmcce1,1);
  setTsmCorrEna(tsmcce2,2);
  setTsmCorrEnaCarry(tsmccec);
  setTsmGhost1Flag(tsmgs1);
  setTsmGhost2Flag(tsmgs2);
  setTsmGhost1Corr(tsmcgs1);
  setTsmGhost2Corr(tsmcgs2);
  setTsmCarryFlag(tsmhsp);

  for (int i=0;i<24;i++) setUsedTraco(i,tstren[i]);
  for (int i=0;i<8;i++) setTsmStatus(i,tsmword[i]);
  
    
}

//--------------
// Destructor --
//--------------
DTConfigTSPhi::~DTConfigTSPhi() {}

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

void
DTConfigTSPhi::setDefaults(const edm::ParameterSet& ps) {

  m_ntss = 1; //dummy param used only in DB config
  m_ntsm = 1; //dummy param used only in DB config

  // Debug flag 
  m_debug = ps.getUntrackedParameter<bool>("Debug");
  
  // Order of quaity bits in TSS for sort1
  int mymsk = ps.getParameter<int>("TSSMSK1");
  if (checkMask(mymsk)) 
    m_tssmsk[0] = mymsk;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSSMSK1 not in correct form: " << mymsk << std::endl;
  }
  
  // Order of quaity bits in TSS for sort2
  mymsk= ps.getParameter<int>("TSSMSK2");  
  if (checkMask(mymsk)) 
    m_tssmsk[1] = mymsk;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSSMSK2 not in correct form: " << mymsk << std::endl;
  }
  
  // Htrig checking in TSS for sort1
  m_tsshte[0] = ps.getParameter<bool>("TSSHTE1");
  
  // Htrig checking in TSS for sort2
  m_tsshte[1] = ps.getParameter<bool>("TSSHTE2");

  // Htrig checking in TSS for carry
  m_tsshte[2] = ps.getParameter<bool>("TSSHTEC");

  // Inner SL checking in TSS for sort1
  m_tssnoe[0] = ps.getParameter<bool>("TSSNOE1");
  
  // Inner SL checking in TSS for sort2
  m_tssnoe[1] = ps.getParameter<bool>("TSSNOE2");
 
  // Inner SL checking in TSS for carry
  m_tssnoe[2] = ps.getParameter<bool>("TSSNOEC");

  // Correlation checking in TSS for sort1
  m_tsscce[0] = ps.getParameter<bool>("TSSCCE1");

  // Correlation checking in TSS for sort2
  m_tsscce[1] = ps.getParameter<bool>("TSSCCE2");
 
  // Correlation checking in TSS for carry
  m_tsscce[2] = ps.getParameter<bool>("TSSCCEC");

  // Ghost 1 supperssion option in TSS
  int mygs = ps.getParameter<int>("TSSGS1");
  if (mygs>=0 && mygs<3)
    m_tssgs1 = mygs;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSSGS1 value is not correct: " << mygs << std::endl;
  }
  
  // Ghost 2 supperssion option in TSS
  mygs= ps.getParameter<int>("TSSGS2");
  if (mygs>=0 && mygs<5)
    m_tssgs2 = mygs;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSSGS2 value is not correct: " << mygs << std::endl;
  }

  // Correlated ghost 1 supperssion option in TSS
  m_tsscgs1 = ps.getParameter<bool>("TSSCGS1");
  
  // Correlated ghost 2 supperssion option in TSS
  m_tsscgs2 = ps.getParameter<bool>("TSSCGS2");

  // Order of quaity bits in TSM for sort1
  mymsk = ps.getParameter<int>("TSMMSK1");
  if (checkMask(mymsk)) 
    m_tsmmsk[0] = mymsk;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMMSK1 not in correct form: " << mymsk << std::endl;
  }

  // Order of quaity bits in TSM for sort2
  mymsk= ps.getParameter<int>("TSMMSK2");
  if (checkMask(mymsk)) 
    m_tsmmsk[1] = mymsk;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMMSK2 not in correct form: " << mymsk << std::endl;
  }
  
  // Htrig checking in TSM for sort1
  m_tsmhte[0] = ps.getParameter<bool>("TSMHTE1");
  
  // Htrig checking in TSM for sort2
  m_tsmhte[1] = ps.getParameter<bool>("TSMHTE2");
 
  // Htrig checking in TSM for carry
  m_tsmhte[2] = ps.getParameter<bool>("TSMHTEC");
  
  // Inner SL checking in TSM for sort1
  m_tsmnoe[0] = ps.getParameter<bool>("TSMNOE1");
  
  // Inner SL checking in TSM for sort2
  m_tsmnoe[1] = ps.getParameter<bool>("TSMNOE2");
 
  // Inner SL checking in TSM for carry
  m_tsmnoe[2] = ps.getParameter<bool>("TSMNOEC");

  // Correlation checking in TSM for sort1
  m_tsmcce[0] = ps.getParameter<bool>("TSMCCE1");
  
  // Correlation checking in TSM for sort2
  m_tsmcce[1] = ps.getParameter<bool>("TSMCCE2");
 
  // Correlation checking in TSM for carry
  m_tsmcce[2] = ps.getParameter<bool>("TSMCCEC");

  // Ghost 1 supperssion option in TSM
  mygs = ps.getParameter<int>("TSMGS1");
  if (mygs>=0 && mygs<3)
    m_tsmgs1 = mygs;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMGS1 value is not correct: " << mygs << std::endl;
  }

  // Ghost 2 supperssion option in TSM
  mygs= ps.getParameter<int>("TSMGS2");
  if (mygs>=0 && mygs<5)
    m_tsmgs2 = mygs;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMGS2 value is not correct: " << mygs << std::endl;
  }

  // Correlated ghost 1 supperssion option in TSM
  m_tsmcgs1 = ps.getParameter<bool>("TSMCGS1");
  
  // Correlated ghost 2 supperssion option in TSM
  m_tsmcgs2 = ps.getParameter<bool>("TSMCGS2");

  // Handling carry in case of pile-up
  int myhsp = ps.getParameter<int>("TSMHSP");
  if (myhsp>=0 && myhsp<3)
    m_tsmhsp = myhsp;
  else {
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMHSP value is not correct: " << myhsp << std::endl;
  }

  // Handling TSMS masking parameters
  m_tsmword.one();
  int word = ps.getParameter<int>("TSMWORD");
  if (word<0 || word>255){
    edm::LogVerbatim("DTTPG") << "DTConfigTSPhi::setDefaults : TSMWORD value is not correct: " << word << std::endl;
  }
  for (int i=0;i<7;i++){
    short int bit = word%2;
    word /= 2;
    if (bit==0) m_tsmword.unset(i);
  }

  m_tstren.one();
  for (int i=0;i<24;i++){
    std::stringstream os;
    os << "TSTREN" << i;
    if (ps.getParameter<bool>(os.str())== 0)
      m_tstren.unset(i);
  }
          
}

int 
DTConfigTSPhi::TSSinTSMD(int stat, int sect) const { //CB it should set value when constructor is called (it should be done when we have station by station config)  

  // Number of TSS for each TSMD (it changes from station to station) The DT stations are indicated in parenthesis
  // in the DT column.
  //
  //      MB                    nb.TSS        nb.TTS per TSMD
  //      1                       3             2   
  //      2                       4             2  
  //      3                       5             3  
  //      4(1,2,3,5,6,7)          6             3   
  //      4(8,12)                 6             3   
  //      4(9,11)                 3             2     
  //      4(4L)                   5             3    
  //      4(4R)                   5             3    
  //      4(10L)                  4             2     
  //      4(10R)                  4             2     
  
  if( stat==1 ||
      stat==2 ||
      ( stat==4 && (sect==9 || sect==11 ||
            sect==10))) {
    return 2;
  }
  return 3;
}

void 
DTConfigTSPhi::print() const {

  std::cout << "******************************************************************************" << std::endl;
  std::cout << "*              DTTrigger configuration : TSPhi chips                         *" << std::endl;
  std::cout << "******************************************************************************" << std::endl << std::endl;
  std::cout << "Debug flag : " <<  debug() << std::endl;
  std::cout << "               TSS Parameters:" << std::endl;
  std::cout <<  "TSSMSK 1/2:" << TssMasking(0) << " " <<  TssMasking(1) << std::endl;
  std::cout << "TSSHTE 1/2/carry :" << TssHtrigEna(0) << " " << TssHtrigEna(1) << " " << TssHtrigEnaCarry() << std::endl;
  std::cout << "TSSNOE 1/2/carry :" << TssInOutEna(0) << " " << TssInOutEna(1) << " " << TssInOutEnaCarry() << std::endl;
  std::cout << "TSSCCE 1/2/carry :" << TssCorrEna(0)  << " " << TssCorrEna(1)  << " " << TssCorrEnaCarry()  << std::endl;
  std::cout << "TSSGS 1/2:" << TssGhost1Flag() << " " << TssGhost2Flag() << std::endl;
  std::cout << "TSSCGS 1/2:" << TssGhost1Corr() << " " << TssGhost2Corr() << std::endl;
  std::cout << "               TSM Parameters:" << std::endl;
  std::cout << "TSMMSK 1/2:" << TsmMasking(0) << " " <<  TsmMasking(1) << std::endl;
  std::cout << "TSMHTE 1/2/carry :" << TsmHtrigEna(0) << " " << TsmHtrigEna(1) << " " << TsmHtrigEnaCarry() << std::endl;
  std::cout << "TSMNOE 1/2/carry :" << TsmInOutEna(0) << " " << TsmInOutEna(1) << " " << TsmInOutEnaCarry() << std::endl;
  std::cout << "TSMCCE 1/2/carry :" << TsmCorrEna(0)  << " " << TsmCorrEna(1)  << " " << TsmCorrEnaCarry()  << std::endl;
  std::cout << "TSMGS 1/2:" <<  TsmGhost1Flag() << " " << TsmGhost2Flag() << std::endl;
  std::cout << "TSMCGS 1/2:" <<  TsmGhost1Corr() << " " << TsmGhost2Corr() << std::endl;
  std::cout << "TSMHSP :" << TsmGetCarryFlag() << std::endl;
  std::cout << "TSTREN[i] :";
  for (int i=1;i<25;i++) std::cout << usedTraco(i) << " ";
  std::cout << std::endl;
  std::cout << "TSMWORD :";
  TsmStatus().print();
  std::cout << std::endl;
//   int stat=4, sect=5;
//   std::cout << "TSSTSMD(4,14 :" <<  TSSinTSMD(stat,sect) << std::endl;
  std::cout << "******************************************************************************" << std::endl;

}
  

int 
DTConfigTSPhi::nValidTSS() const{

  bool isMaskValid = checkMask(TssMasking(0)) && checkMask(TssMasking(1));
  bool isGsValid = (TssGhost1Flag()>=0 && TssGhost1Flag()<3) && (TssGhost2Flag()>=0 &&  TssGhost2Flag()<5);
  int nValidTSS = static_cast<int>(isMaskValid && isGsValid ? m_ntss : 0);   

  return nValidTSS;
}

int 
DTConfigTSPhi::nValidTSM() const{

  bool isMaskValid = checkMask( TsmMasking(0)) && checkMask(TsmMasking(1));
  bool isGsValid = (TsmGhost1Flag()>=0 && TsmGhost1Flag()<3) && (TsmGhost2Flag()>=0 &&  TsmGhost2Flag()<5);
  bool isCarryValid =  TsmGetCarryFlag()>=0 && TsmGetCarryFlag()<3;
  int nValidTSM = static_cast<int>(isMaskValid && isGsValid && isCarryValid ? m_ntsm : 0); 
  
  return nValidTSM;

}

bool
DTConfigTSPhi::checkMask(unsigned short msk) const{
  
  bool hasone = false;
  bool hastwo = false;
  bool hasthree = false;
  for(int i=0;i<3;i++){
    int mynum = msk%10;
    switch (mynum){
    case 1:
      hasone = true;
      break;
    case 2:
      hastwo = true;
      break;
    case 3:
      hasthree =true;
      break;
    }
    msk /= 10;
  }
  if (hasone==true && hastwo==true && hasthree==true) return true;
  return false;

}