EcalStatusAnalyzer.cc

Go to the documentation of this file.

/* 
 *  \class EcalStatusAnalyzer
 *
 *  author: Julie Malcles - CEA/Saclay
 *  author: Gautier Hamel De Monchenault - CEA/Saclay
 */

#include "EcalStatusAnalyzer.h"

#include "TFile.h"
#include "TTree.h"
#include "TCut.h"
#include "TPaveText.h"
#include "TBranch.h"

#include <fstream>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <ctime>

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <DataFormats/EcalDigi/interface/EcalDigiCollections.h>
#include <FWCore/Utilities/interface/Exception.h>

#include <FWCore/Framework/interface/Event.h>
#include <FWCore/Framework/interface/MakerMacros.h>
#include <FWCore/ParameterSet/interface/ParameterSet.h>

#include <DataFormats/EcalDigi/interface/EcalDigiCollections.h>
#include <DataFormats/EcalDetId/interface/EcalDetIdCollections.h>
#include <DataFormats/EcalRawData/interface/EcalRawDataCollections.h>
#include <TBDataFormats/EcalTBObjects/interface/EcalTBEventHeader.h>
#include <DataFormats/Provenance/interface/Timestamp.h>
using namespace std;

//========================================================================
EcalStatusAnalyzer::EcalStatusAnalyzer(const edm::ParameterSet& iConfig)
//========================================================================
 :
iEvent(0),

// framework parameters with default values
_dataType(        iConfig.getUntrackedParameter< std::string >( "dataType",         "h4"   ) ) // h4 or p5

//========================================================================

{

  //now do what ever initialization is needed

  resdir_                 = iConfig.getUntrackedParameter<std::string>("resDir");
  statusfile_             = iConfig.getUntrackedParameter<std::string>("statusFile");

  eventHeaderCollection_  = iConfig.getParameter<std::string>("eventHeaderCollection");
  eventHeaderProducer_    = iConfig.getParameter<std::string>("eventHeaderProducer");

}


//========================================================================
EcalStatusAnalyzer::~EcalStatusAnalyzer(){
//========================================================================


  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)

}



//========================================================================
void EcalStatusAnalyzer::beginJob() {
//========================================================================
 

  
  // Initializations
  

  nSM=0;
  fedID=0;
  runType=-999;
  runNum=-999;
  event=0;
 

}


//========================================================================
void EcalStatusAnalyzer:: analyze( const edm::Event & e, const  edm::EventSetup& c){
//========================================================================

  ++iEvent;

  // retrieving DCC header
  edm::Handle<EcalRawDataCollection> pDCCHeader;
  const  EcalRawDataCollection* DCCHeader=nullptr;
  try {
    e.getByLabel(eventHeaderProducer_,eventHeaderCollection_, pDCCHeader);
    DCCHeader=pDCCHeader.product();
  }catch ( std::exception& ex ) {
    std::cerr << "Error! can't get the product  retrieving DCC header " << eventHeaderCollection_.c_str() << std::endl;
  }

  // retrieving TB event header

  edm::Handle<EcalTBEventHeader> pEventHeader; 
  const EcalTBEventHeader* evtHeader=nullptr;
  if ( _dataType == "h4" ){
    try {
      e.getByLabel( eventHeaderProducer_ , pEventHeader );
      evtHeader = pEventHeader.product(); // get a ptr to the product
    } catch ( std::exception& ex ) {
      std::cerr << "Error! can't get the product " << eventHeaderProducer_.c_str() << std::endl;
    }
    
    timeStampCur=evtHeader->begBurstTimeSec();
    nSM=evtHeader->smInBeam();
    
  }
  
  // Get Timestamp 
  
  edm::Timestamp Time=e.time();
  
  if ( _dataType != "h4" ){
    timeStampCur = Time.value();
  }
  
  // ====================================
  // Decode Basic DCCHeader Information 
  // ====================================

  for ( EcalRawDataCollection::const_iterator headerItr= DCCHeader->begin();headerItr != DCCHeader->end(); 
    ++headerItr ) {

    // Get run type and run number 
    runType=headerItr->getRunType();
    runNum=headerItr->getRunNumber();
    event=headerItr->getLV1();
    dccID=headerItr->getDccInTCCCommand();
    fedID=headerItr->fedId();  

    short VFEGain=headerItr->getMgpaGain() ;
    short MEMGain=headerItr->getMemGain() ;

   
    // Retrieve laser color and event number
    
    EcalDCCHeaderBlock::EcalDCCEventSettings settings = headerItr->getEventSettings();

    int laser_color = settings.wavelength;
    int laser_power = settings.LaserPower ;
    int laser_filter = settings.LaserFilter ;
    int laser_delay = settings.delay ;
    if(  laser_color <0 ) return;
    // int laser_ = settings.MEMVinj;

    bool isLas=false;
    bool isTP=false;
    bool isPed=false;

    if(runType==EcalDCCHeaderBlock::LASER_STD || runType==EcalDCCHeaderBlock::LASER_GAP
       || runType==EcalDCCHeaderBlock::LASER_POWER_SCAN || runType==EcalDCCHeaderBlock::LASER_DELAY_SCAN) isLas=true;

    else if(runType==EcalDCCHeaderBlock::TESTPULSE_MGPA || runType==EcalDCCHeaderBlock::TESTPULSE_GAP
        || runType==EcalDCCHeaderBlock::TESTPULSE_SCAN_MEM ) isTP=true;

    else if(runType==EcalDCCHeaderBlock::PEDESTAL_STD  || runType==EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN 
        || runType==EcalDCCHeaderBlock::PEDESTAL_25NS_SCAN  ) isPed=true;


    // take event only if the fed corresponds to the DCC in TCC
    // and fill gain stuff with value of 1st event
    
    
    if( 600+dccID != fedID ) continue;
    

    bool doesExist=false;
    
    if( (isFedLasCreated.count(fedID)==1 && isLas ) || ( isFedTPCreated.count(fedID)==1 && isTP ) || ( isFedPedCreated.count(fedID)==1 && isPed )) doesExist=true;
    else if(isLas) isFedLasCreated[fedID]=1;
    else if(isTP) isFedTPCreated[fedID]=1;
    else if(isPed) isFedPedCreated[fedID]=1;
    
    
    
    if(!doesExist){
       
      // create new entry for laser

      if (isLas){

    fedIDsLas.push_back(fedID);
    dccIDsLas.push_back(dccID);
    
    timeStampBegLas[fedID]=timeStampCur;
    timeStampEndLas[fedID]=timeStampCur;

    nEvtsLas[fedID]=1;
    runTypeLas[fedID]=runType;

    if (laser_color==iBLUE) {
      nBlueLas[fedID]=1;
      laserPowerBlue[fedID] = laser_power;
      laserFilterBlue[fedID]= laser_filter;
      laserDelayBlue[fedID] = laser_delay;
    }else if (laser_color==iIR) {
      nRedLas[fedID]=1;
      laserPowerRed[fedID] = laser_power;
      laserFilterRed[fedID]= laser_filter;
      laserDelayRed[fedID] = laser_delay;
    }

    MGPAGainLas[fedID]=VFEGain;
    MEMGainLas[fedID]=MEMGain;

      
      }

      // or create new entry for test-pulse
      else if (isTP){
    
    fedIDsTP.push_back(fedID);
    dccIDsTP.push_back(dccID);
    
    nEvtsTP[fedID]=1;
    runTypeTP[fedID]=runType;

    timeStampBegTP[fedID]=timeStampCur;
    timeStampEndTP[fedID]=timeStampCur;

    MGPAGainTP[fedID]=VFEGain;
    MEMGainTP[fedID]=MEMGain;

    // or create new entry for pedestal
    
      } else if (isPed){
    
    fedIDsPed.push_back(fedID);
    dccIDsPed.push_back(dccID);
    
    nEvtsPed[fedID]=1;
    runTypePed[fedID]=runType;
    
    timeStampBegPed[fedID]=timeStampCur;
    timeStampEndPed[fedID]=timeStampCur;
    
    MGPAGainPed[fedID]=VFEGain;
    MEMGainPed[fedID]=MEMGain;
    
      } 

    }else{
      if (isLas){   
    nEvtsLas[fedID]++;
    if (laser_color==iBLUE)nBlueLas[fedID]++;
    else if (laser_color==iIR)nRedLas[fedID]++;
       
    if(timeStampCur<timeStampBegLas[fedID])timeStampBegLas[fedID]=timeStampCur;
    if(timeStampCur>timeStampEndLas[fedID])timeStampEndLas[fedID]=timeStampCur;

      }else if (isTP){  
    nEvtsTP[fedID]++;
    if(timeStampCur<timeStampBegTP[fedID])timeStampBegTP[fedID]=timeStampCur;
    if(timeStampCur>timeStampEndTP[fedID])timeStampEndTP[fedID]=timeStampCur;
      }else if (isPed){ 
    nEvtsPed[fedID]++;
    if(timeStampCur<timeStampBegPed[fedID])timeStampBegPed[fedID]=timeStampCur;
    if(timeStampCur>timeStampEndPed[fedID])timeStampEndPed[fedID]=timeStampCur;
      } 
    }  
  }

}// analyze


//========================================================================
void EcalStatusAnalyzer::endJob() {
//========================================================================

  // Create output status file

  std::stringstream namefile;
  namefile << resdir_ <<"/"<<statusfile_;

  string statusfile=namefile.str();
  
  std::ofstream statusFile(statusfile.c_str(), std::ofstream::out);
  
  
  if(!fedIDsLas.empty() && fedIDsLas.size()==dccIDsLas.size()){
    
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;
    statusFile <<"                LASER Events              "<<std::endl;
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;
    
    for(unsigned int i=0;i<fedIDsLas.size();i++){
       
      statusFile <<"RUNTYPE = "<< runTypeLas[fedIDsLas.at(i)]<< std::endl;
      statusFile <<"FEDID = "<< fedIDsLas.at(i) << std::endl;
      statusFile <<"DCCID = "<< dccIDsLas.at(i) << std::endl;
      statusFile <<"TIMESTAMP_BEG = "<<timeStampBegLas[fedIDsLas.at(i)] << std::endl;
      statusFile <<"TIMESTAMP_END = "<<timeStampEndLas[fedIDsLas.at(i)] << std::endl;
      statusFile <<"MPGA_GAIN = "<<MGPAGainLas[fedIDsLas.at(i)] << std::endl;
      statusFile <<"MEM_GAIN  = "<<MEMGainLas[fedIDsLas.at(i)] << std::endl;
      statusFile <<"EVENTS = "<< nEvtsLas[fedIDsLas.at(i)]<< std::endl;
      
      if(nBlueLas[fedIDsLas.at(i)]>0){
    statusFile <<"            blue laser events = "<< nBlueLas[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            blue laser power  = "<< laserPowerBlue[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            blue laser filter = "<< laserFilterBlue[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            blue laser delay  = "<< laserDelayBlue[fedIDsLas.at(i)]<< std::endl;
      }
      
      if(nRedLas[fedIDsLas.at(i)]>0){
    statusFile <<"            ired laser events = "<< nRedLas[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            ired laser power  = "<< laserPowerRed[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            ired laser filter = "<< laserFilterRed[fedIDsLas.at(i)]<< std::endl;
    statusFile <<"            ired laser delay  = "<< laserDelayRed[fedIDsLas.at(i)]<< std::endl;
      }
      
      if(i<fedIDsLas.size()-1) statusFile <<"-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="<<std::endl;
      else  statusFile <<"  "<<std::endl;
    }    
  }
  
  if(!fedIDsTP.empty() && fedIDsTP.size()==dccIDsTP.size()){
    
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;
    statusFile <<"             TESTPULSE Events            "<<std::endl;
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;

    for(unsigned int i=0;i<fedIDsTP.size();i++){
      
      statusFile <<"RUNTYPE = "<< runTypeTP[fedIDsTP.at(i)]<< std::endl;
      statusFile <<"FEDID = "<< fedIDsTP.at(i) << std::endl;
      statusFile <<"DCCID = "<< dccIDsTP.at(i) << std::endl;
      statusFile <<"TIMESTAMP_BEG = "<<timeStampBegTP[fedIDsTP.at(i)] << std::endl;
      statusFile <<"TIMESTAMP_END = "<<timeStampEndTP[fedIDsTP.at(i)] << std::endl;
      statusFile <<"MPGA_GAIN = "<<MGPAGainTP[fedIDsTP.at(i)] << std::endl;
      statusFile <<"MEM_GAIN  = "<<MEMGainTP[fedIDsTP.at(i)] << std::endl;
      statusFile <<"EVENTS = "<< nEvtsTP[fedIDsTP.at(i)]<< std::endl;
      if(i<fedIDsTP.size()-1) statusFile <<"-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="<<std::endl;
      else  statusFile <<"  "<<std::endl;
    }     
  }

  if(!fedIDsPed.empty() && fedIDsPed.size()==dccIDsPed.size()){
    
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;
    statusFile <<"               PEDESTAL Events              "<<std::endl;
    statusFile <<"+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+="<<std::endl;

    for(unsigned int i=0;i<fedIDsPed.size();i++){
      
      statusFile <<"RUNTYPE = "<< runTypePed[fedIDsPed.at(i)]<< std::endl;
      statusFile <<"FEDID = "<< fedIDsPed.at(i) << std::endl;
      statusFile <<"DCCID = "<< dccIDsPed.at(i) << std::endl;
      statusFile <<"TIMESTAMP_BEG = "<<timeStampBegPed[fedIDsPed.at(i)] << std::endl;
      statusFile <<"TIMESTAMP_END = "<<timeStampEndPed[fedIDsPed.at(i)] << std::endl;
      statusFile <<"MPGA_GAIN = "<<MGPAGainPed[fedIDsPed.at(i)] << std::endl;
      statusFile <<"MEM_GAIN  = "<<MEMGainPed[fedIDsPed.at(i)] << std::endl;
      statusFile <<"EVENTS = "<< nEvtsPed[fedIDsPed.at(i)]<< std::endl;
      if(i<fedIDsPed.size()-1) statusFile <<"-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="<<std::endl;
      else  statusFile <<"  "<<std::endl;
    }     
  }
  statusFile <<" ... header done"<<std::endl;
  
  statusFile.close();
  
}


DEFINE_FWK_MODULE(EcalStatusAnalyzer);