/data/refman/pasoursint/CMSSW_4_1_8_patch9/src/CondFormats/L1TObjects/src/L1MuDTPtaLut.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuDTPtaLut
//
//   Description: Look-up tables for pt assignment 
//
//
//   $Date: 2010/05/12 23:03:43 $
//   $Revision: 1.7 $
//
//   Author :
//   N. Neumeister            CERN EP
//   J. Troconiz              UAM Madrid
//
//--------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------

#include "CondFormats/L1TObjects/interface/L1MuDTPtaLut.h"

//---------------
// C++ Headers --
//---------------

#include <iostream>
#include <ostream>
#include <iomanip>
#include <string>
#include <cstdlib>

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

#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "CondFormats/L1TObjects/interface/DTTFBitArray.h"
#include "CondFormats/L1TObjects/interface/L1MuDTAssParam.h"
#include "CondFormats/L1TObjects/interface/L1TriggerLutFile.h"

using namespace std;

// --------------------------------
//       class L1MuDTPtaLut
//---------------------------------

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

L1MuDTPtaLut::L1MuDTPtaLut() : 
                  pta_lut(0), 
                  pta_threshold(MAX_PTASSMETH/2) {

  pta_lut.reserve(MAX_PTASSMETH);
  pta_threshold.reserve(MAX_PTASSMETH/2);
  setPrecision();
  
  //  if ( load() != 0 ) {
  //    cout << "Can not open files to load pt-assignment look-up tables for DTTrackFinder!" << endl;
  //  }

  //  if ( L1MuDTTFConfig::Debug(6) ) print();
  
}


//--------------
// Destructor --
//--------------

L1MuDTPtaLut::~L1MuDTPtaLut() {

  vector<LUT>::iterator iter;
  for ( iter = pta_lut.begin(); iter != pta_lut.end(); iter++ ) {
    (*iter).clear();
  }

  pta_lut.clear();
  pta_threshold.clear();

}


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

//
// reset pt-assignment look-up tables
//
void L1MuDTPtaLut::reset() {

  pta_lut.clear();
  pta_threshold.clear();

}


//
// load pt-assignment look-up tables
//
int L1MuDTPtaLut::load() {

  // get directory name
  string defaultPath = "L1TriggerConfig/DTTrackFinder/parameters/";
  string pta_dir = "L1TriggerData/DTTrackFinder/Ass/";
  string pta_str = "";

  // precision : in the look-up tables the following precision is used :
  // phi ...12 bits (address) and  pt ...5 bits
  // now convert phi and phib to the required precision

  int sh_phi  = 12 - nbit_phi;

  // loop over all pt-assignment methods
  for ( int pam = 0; pam < MAX_PTASSMETH; pam++ ) { 
    switch ( pam ) {
      case PT12L  : { pta_str = "pta12l"; break; }
      case PT12H  : { pta_str = "pta12h"; break; }
      case PT13L  : { pta_str = "pta13l"; break; }
      case PT13H  : { pta_str = "pta13h"; break; }
      case PT14L  : { pta_str = "pta14l"; break; }
      case PT14H  : { pta_str = "pta14h"; break; }
      case PT23L  : { pta_str = "pta23l"; break; }
      case PT23H  : { pta_str = "pta23h"; break; }
      case PT24L  : { pta_str = "pta24l"; break; }
      case PT24H  : { pta_str = "pta24h"; break; }
      case PT34L  : { pta_str = "pta34l"; break; }
      case PT34H  : { pta_str = "pta34h"; break; }
      case PT12LO : { pta_str = "pta12l_ovl"; break; }
      case PT12HO : { pta_str = "pta12h_ovl"; break; }
      case PT13LO : { pta_str = "pta13l_ovl"; break; }
      case PT13HO : { pta_str = "pta13h_ovl"; break; }
      case PT14LO : { pta_str = "pta14l_ovl"; break; }
      case PT14HO : { pta_str = "pta14h_ovl"; break; }
      case PT23LO : { pta_str = "pta23l_ovl"; break; }
      case PT23HO : { pta_str = "pta23h_ovl"; break; }
      case PT24LO : { pta_str = "pta24l_ovl"; break; }
      case PT24HO : { pta_str = "pta24h_ovl"; break; }
      case PT34LO : { pta_str = "pta34l_ovl"; break; }
      case PT34HO : { pta_str = "pta34h_ovl"; break; }
      case PT15LO : { pta_str = "pta15l_ovl"; break; }
      case PT15HO : { pta_str = "pta15h_ovl"; break; }
      case PT25LO : { pta_str = "pta25l_ovl"; break; }
      case PT25HO : { pta_str = "pta25h_ovl"; break; }      
    }

    // assemble file name
    edm::FileInPath lut_f = edm::FileInPath(string(defaultPath + pta_dir + pta_str + ".lut"));
    string pta_file = lut_f.fullPath();

    // open file
    L1TriggerLutFile file(pta_file);
    if ( file.open() != 0 ) return -1;
    //    if ( L1MuDTTFConfig::Debug(1) ) cout << "Reading file : " 
    //                                         << file.getName() << endl; 

    // get the right shift factor
    int shift = sh_phi;
    int adr_old = -2048 >> shift;

    LUT tmplut;

    int number = -1;
    int sum_pt = 0;

    if ( file.good() ) {
      int threshold = file.readInteger();
      pta_threshold[pam/2] = threshold;
    }
    
    // read values and shift to correct precision
    while ( file.good() ) {
        
      int adr = (file.readInteger()) >> shift;
      int pt  = file.readInteger();

      number++;
      
      if ( adr != adr_old ) {
        tmplut.insert(make_pair( adr_old, (sum_pt/number) ));

        adr_old = adr;
        number = 0;
        sum_pt = 0;
      }
      
      sum_pt += pt;
      
      if ( !file.good() ) file.close();
      
    }

    file.close();
    pta_lut.push_back(tmplut);
  }
  return 0;

}


//
// print pt-assignment look-up tables
//
void L1MuDTPtaLut::print() const {

  cout << endl;
  cout << "L1 barrel Track Finder Pt-Assignment look-up tables :" << endl;
  cout << "=====================================================" << endl;
  cout << endl;
  cout << "Precision : " << endl;
  cout << '\t' << setw(2) << nbit_phi  << " bits are used for phi "  << endl;

  // loop over all pt-assignment methods
  for ( int pam = 0; pam < MAX_PTASSMETH; pam++ ) {
 
    cout << endl;
    cout << "Pt-Assignment Method : " << static_cast<PtAssMethod>(pam) << endl;
    cout << "============================" << endl;
    cout << endl;

    cout << "\t Threshold : " << getPtLutThreshold(pam/2) << endl << endl;

    int maxbits = nbit_phi;
  
    cout << "      address";
    for ( int i = 0; i < maxbits; i++ ) cout << ' ';
    cout << "  value" << endl;
    for ( int i = 0; i < maxbits; i++ ) cout << '-';    
    cout << "-------------------------" << endl;

    LUT::const_iterator iter = pta_lut[pam].begin();
    while ( iter != pta_lut[pam].end() ) {
      int address = (*iter).first;
      int value   = (*iter).second;

      DTTFBitArray<12> b_address(static_cast<unsigned>(abs(address)));
      DTTFBitArray<5> b_value(static_cast<unsigned>(abs(value)));

      if ( address < 0 ) b_address.twoComplement();

      cout.setf(ios::right,ios::adjustfield);
      cout << " " << setbase(10) << setw(5) << address << " (";
      for ( int i = maxbits-1; i >= 0; i-- ) cout << b_address[i];  
      cout << ")   " << setw(3) << value << " (";
      b_value.print();
      cout << ")" << endl;

      iter++;
    }
    
  }

  cout << endl;   
  
}


//
// get pt value for a given address
//
int L1MuDTPtaLut::getPt(int pta_ind, int address) const {

  LUT::const_iterator iter = pta_lut[pta_ind].find(address);
  if ( iter != pta_lut[pta_ind].end() ) {
    return (*iter).second;
  }
  else {
    cerr << "PtaLut::getPt : can not find address " << address << endl;
    return 0;
  }

}


//
// get pt-assignment LUT threshold
//
int L1MuDTPtaLut::getPtLutThreshold(int pta_ind) const {

  if ( pta_ind >= 0 && pta_ind < MAX_PTASSMETH/2 ) {
    return pta_threshold[pta_ind];
  }
  else {
    cerr << "PtaLut::getPtLutThreshold : can not find threshold " << pta_ind << endl;
    return 0;
  }

}


//
// set precision for look-up tables
//
void L1MuDTPtaLut::setPrecision() {

  nbit_phi  = 12;  

}