CastorRawToDigi.cc

Go to the documentation of this file.

#include "EventFilter/CastorRawToDigi/plugins/CastorRawToDigi.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDNumbering.h"
#include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Run.h"
#include <fstream>
#include "CalibFormats/CastorObjects/interface/CastorDbService.h"
#include "CalibFormats/CastorObjects/interface/CastorDbRecord.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include "EventFilter/CastorRawToDigi/interface/CastorRawCollections.h"
#include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h"
#include "Geometry/CaloTopology/interface/HcalTopology.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
using namespace std;


CastorRawToDigi::CastorRawToDigi(edm::ParameterSet const& conf):
  dataTag_(conf.getParameter<edm::InputTag>("InputLabel")),
  unpacker_(conf.getParameter<int>("CastorFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
  zdcunpacker_(conf.getParameter<int>("CastorFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
  ctdcunpacker_(conf.getParameter<int>("CastorFirstFED"),conf.getParameter<int>("firstSample"),conf.getParameter<int>("lastSample")),
  filter_(conf.getParameter<bool>("FilterDataQuality"),conf.getParameter<bool>("FilterDataQuality"),false,0,0,-1),
  fedUnpackList_(conf.getUntrackedParameter<std::vector<int> >("FEDs",std::vector<int>())),
  firstFED_(conf.getParameter<int>("CastorFirstFED")),
  complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData",false)),
  usingctdc_(conf.getParameter<bool>("CastorCtdc")),
  unpackTTP_(conf.getParameter<bool>("UnpackTTP")),
  unpackZDC_(conf.getParameter<bool>("UnpackZDC")),
  silent_(conf.getUntrackedParameter<bool>("silent",true)),
  usenominalOrbitMessageTime_(conf.getParameter<bool>("UseNominalOrbitMessageTime")),
  expectedOrbitMessageTime_(conf.getParameter<int>("ExpectedOrbitMessageTime"))

{
  if (fedUnpackList_.empty()) {
    for (int i=FEDNumbering::MINCASTORFEDID; i<=FEDNumbering::MAXCASTORFEDID; i++)
     fedUnpackList_.push_back(i);
  } 

  unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);  
  std::ostringstream ss;
  for (unsigned int i=0; i<fedUnpackList_.size(); i++) 
    ss << fedUnpackList_[i] << " ";
  edm::LogInfo("CASTOR") << "CastorRawToDigi will unpack FEDs ( " << ss.str() << ")";
    
  // products produced...
  produces<CastorDigiCollection>();
  produces<ZDCDigiCollection>();
  produces<CastorTrigPrimDigiCollection>();
  produces<HcalUnpackerReport>();
  if (unpackTTP_)
    produces<HcalTTPDigiCollection>();

  tok_input_ = consumes<FEDRawDataCollection>(dataTag_);

}

// Virtual destructor needed.
CastorRawToDigi::~CastorRawToDigi() { }  

// Functions that gets called by framework every event
void CastorRawToDigi::produce(edm::Event& e, const edm::EventSetup& es)
{
  // Step A: Get Inputs 
  edm::Handle<FEDRawDataCollection> rawraw;  
  e.getByToken(tok_input_,rawraw);
  // get the mapping
  edm::ESHandle<CastorDbService> pSetup;
  es.get<CastorDbRecord>().get( pSetup );
  const CastorElectronicsMap* readoutMap=pSetup->getCastorMapping();
  
  // Step B: Create empty output  : three vectors for three classes...
  std::vector<CastorDataFrame> castor;
  std::vector<ZDCDataFrame> zdc;
  std::vector<HcalTTPDigi> ttp;
  std::vector<CastorTriggerPrimitiveDigi> htp;

  auto report = std::make_unique<HcalUnpackerReport>();

  CastorRawCollections colls;
  colls.castorCont=&castor;
  colls.zdcCont=&zdc;
  if (unpackTTP_) colls.ttp=&ttp;
  colls.tpCont=&htp;
 
  // Step C: unpack all requested FEDs
  const FEDRawData& fed722 = rawraw->FEDData(722);
  const int fed722size = fed722.size();
  const FEDRawData& fed693 = rawraw->FEDData(693);
  const int fed693size = fed693.size();
  for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
    const FEDRawData& fed = rawraw->FEDData(*i);
    //std::cout<<"Fed number "<<*i<<"is being worked on"<<std::endl;
    if (*i == 693 && fed693size == 0 && fed722size != 0)
      continue;
    if (*i == 722 && fed722size == 0 && fed693size != 0)
      continue;      
      
    if (*i!=693 && *i!=722)
      {
    if (fed.size()==0) 
      {
        if (complainEmptyData_) 
          {
        edm::LogWarning("EmptyData") << "No data for FED " << *i;
        report->addError(*i);
          }
      } 
    else if (fed.size()<8*3) 
      {
        edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
        report->addError(*i);
      } 
    else 
      {
        try 
          {
        if ( usingctdc_ ) 
          { 
            ctdcunpacker_.unpack(fed,*readoutMap,colls, *report);
          } 
        else 
          {
            unpacker_.unpack(fed,*readoutMap,colls, *report);
          }
        report->addUnpacked(*i);
          } 
        catch (cms::Exception& e) 
          {
        edm::LogWarning("Unpacking error") << e.what();
        report->addError(*i);
          } catch (...) 
          {
        edm::LogWarning("Unpacking exception");
        report->addError(*i);
          }
      }
      }

    if (*i==693 && unpackZDC_)
      {
    if (fed.size()==0)
      {
        if (complainEmptyData_) 
          {
            edm::LogWarning("EmptyData") << "No data for FED " << *i;
            report->addError(*i);
          }
      }
    if (fed.size()!=0)
      {
        zdcunpacker_.unpack(fed,*readoutMap,colls,*report);
        report->addUnpacked(*i); 
      }
      }
      
    if (*i==722 && unpackZDC_)
      {
    if (fed.size()==0)
      {
        if (complainEmptyData_) 
          {
            edm::LogWarning("EmptyData") << "No data for FED " << *i;
            report->addError(*i);
          }
      }
    if (fed.size()!=0)
      {
        zdcunpacker_.unpack(fed,*readoutMap,colls,*report);
        report->addUnpacked(*i);
      }
      }      

  }//end of loop over feds

  // Step B: encapsulate vectors in actual collections
  auto castor_prod = std::make_unique<CastorDigiCollection>();
  auto htp_prod = std::make_unique<CastorTrigPrimDigiCollection>();

  castor_prod->swap_contents(castor);
  htp_prod->swap_contents(htp);

  // Step C2: filter FEDs, if required
  if (filter_.active()) {
    CastorDigiCollection filtered_castor=filter_.filter(*castor_prod,*report);
    
    castor_prod->swap(filtered_castor);
   }
   
   // Step D: Put outputs into event
   // just until the sorting is proven
   castor_prod->sort();
   htp_prod->sort();
   
   if(unpackZDC_)
     {
       auto zdc_prod = std::make_unique<ZDCDigiCollection>();
       zdc_prod->swap_contents(zdc);
       
       zdc_prod->sort();
       e.put(std::move(zdc_prod));
     }
   
   e.put(std::move(castor_prod));
   e.put(std::move(htp_prod));
   
  if (unpackTTP_) {
    auto prod = std::make_unique<HcalTTPDigiCollection>();
    prod->swap_contents(ttp);
    
    prod->sort();
    e.put(std::move(prod));
  }
  e.put(std::move(report));
}
void CastorRawToDigi::beginRun(edm::Run const& irun, edm::EventSetup const& es){
    if ( usenominalOrbitMessageTime_ ) {
        if ( irun.run() > 132640 ) { 
            expectedOrbitMessageTime_ = 3560;
        } else if ( irun.run() > 132174 ) {
            expectedOrbitMessageTime_ = 3559;
        } else if ( irun.run() > 124371 ) {
            expectedOrbitMessageTime_ = 3557;
        } else if ( irun.run() > 123984 ) {
            expectedOrbitMessageTime_ = 3559;
        } else if ( irun.run() > 123584 ) {
            expectedOrbitMessageTime_ = 2;
        } else {
            expectedOrbitMessageTime_ = 3562;
        }
        unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);
    }
}