L1TLSBlock.cc

Go to the documentation of this file.

// 

// This class header
#include "DQMOffline/L1Trigger/interface/L1TLSBlock.h"

// System include files
// --

//#include "DQMServices/Core/interface/DQMStore.h"
//
//#include "DataFormats/Scalers/interface/LumiScalers.h"
//#include "DataFormats/Scalers/interface/Level1TriggerRates.h"
//#include "DataFormats/Scalers/interface/Level1TriggerScalers.h"
//
//#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
//#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerEvmReadoutRecord.h"
//
//#include "DataFormats/Common/interface/ConditionsInEdm.h" // Parameters associated to Run, LS and Event
//
//#include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"
//#include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
//#include "CondFormats/L1TObjects/interface/L1GtPrescaleFactors.h"
//#include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
//#include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsAlgoTrigRcd.h"
//#include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
//
//#include "DQMOffline/L1Trigger/interface/L1TMenuHelper.h"
//
//#include "TList.h"

using namespace std;

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

L1TLSBlock::L1TLSBlock(){

  // Initialize LumiRangeList object. This will be redone at every doBlocking call. Perhaps rethink this
  initializeIO(false);
  
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

L1TLSBlock::~L1TLSBlock(){}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

L1TLSBlock::LumiRangeList L1TLSBlock::doBlocking(const LumiTestDoubleList& inputList, double threshold, BLOCKBY blockingMethod)
{
  inputDoubleList_ = inputList;
  thresholdD_ = threshold;
  
  initializeIO(true);
  
  orderTestDoubleList();
  
  switch(blockingMethod){
  case STATISTICS:
    blockByStatistics();
    break;
  default:
    cout << "[L1TLSBlock::doBlocking()]: Blocking method does not exist or is not implemented" << endl;
  }
  
  
  return outputList_;
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

L1TLSBlock::LumiRangeList L1TLSBlock::doBlocking(const LumiTestIntList& inputList, int threshold, BLOCKBY blockingMethod)
{
  inputIntList_ = inputList;
  thresholdI_ = threshold;
  
  initializeIO(true);
  
  orderTestIntList();
  
  switch(blockingMethod){
  case STATISTICS:
    cout << "[L1TLSBlock::doBlocking()]: Blocking by statistics require doubles as inputs for test variable and threshold" << endl;
    break;
  default:
    cout << "[L1TLSBlock::doBlocking()]: Blocking method does not exist or is not implemented" << endl;
  }
  
  return outputList_;
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

void L1TLSBlock::initializeIO(bool outputOnly){
  if(!outputOnly){
    inputIntList_.clear();
    inputDoubleList_.clear();
  }
  outputList_.clear();
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

void L1TLSBlock::orderTestDoubleList(){
  std::sort(inputDoubleList_.begin(), inputDoubleList_.end(), sort_pair_first<int, double>());
  // std::sort(v.begin(), v.end(), sort_pair_second<int, std::greater<int> >());
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

void L1TLSBlock::orderTestIntList(){
  std::sort(inputIntList_.begin(), inputIntList_.end(), sort_pair_first<int, int>());
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

void L1TLSBlock::blockByStatistics(){
  LumiRange currentRange;
  double currentError(0);
  bool resetFlag(true);

  for(LumiTestDoubleList::iterator i=inputDoubleList_.begin(); i!=inputDoubleList_.end(); i++){
    if(resetFlag){
      currentRange = std::make_pair(i->first,i->first);
      resetFlag = false;
    }
    else
      currentRange = std::make_pair(currentRange.first,i->first);
    currentError = computeErrorFromRange(currentRange);
    if(currentError < thresholdD_){
      outputList_.push_back(currentRange);
      resetFlag = true;
    }
    
  }
}

double L1TLSBlock::computeErrorFromRange(LumiRange& lumiRange){
  std::vector<double> errorList;
  errorList.clear();

  for(size_t i=0; i < inputDoubleList_.size(); i++){
    if(inputDoubleList_[i].first>lumiRange.first && inputDoubleList_[i].first<lumiRange.second)
      errorList.push_back(inputDoubleList_[i].second);
  }
  
  double error(-1);
  for(size_t i=0; i<errorList.size(); i++)
    error += 1 / (errorList[i] * errorList[i] );
  return error;

}