BeamSpotOnlineProducer.cc

Go to the documentation of this file.

#include "RecoVertex/BeamSpotProducer/interface/BeamSpotOnlineProducer.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/IOVSyncValue.h"
#include "CondFormats/DataRecord/interface/BeamSpotObjectsRcd.h"
#include "CondFormats/BeamSpotObjects/interface/BeamSpotObjects.h"

#include "FWCore/Framework/interface/MakerMacros.h"


using namespace edm;


BeamSpotOnlineProducer::BeamSpotOnlineProducer(const ParameterSet& iconf)
  : changeFrame_ ( iconf.getParameter<bool>  ("changeToCMSCoordinates") )
  , theMaxZ      ( iconf.getParameter<double>("maxZ")                   )
  , theSetSigmaZ ( iconf.getParameter<double>("setSigmaZ")              )
  , scalerToken_               ( consumes<BeamSpotOnlineCollection>       ( iconf.getParameter<InputTag>("src")       ) )
  , l1GtEvmReadoutRecordToken_ ( consumes<L1GlobalTriggerEvmReadoutRecord>( iconf.getParameter<InputTag>("gtEvmLabel")) )
  , theBeamShoutMode ( iconf.getUntrackedParameter<unsigned int> ("beamMode",11) )
{

  theMaxR2 = iconf.getParameter<double>("maxRadius");
  theMaxR2*=theMaxR2;

  produces<reco::BeamSpot>();

} 

BeamSpotOnlineProducer::~BeamSpotOnlineProducer() {}

void
BeamSpotOnlineProducer::produce(Event& iEvent, const EventSetup& iSetup)
{
  //shout MODE only in stable beam
  bool shoutMODE=false;
  edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord;
  if (iEvent.getByToken(l1GtEvmReadoutRecordToken_, gtEvmReadoutRecord)){
    if (gtEvmReadoutRecord->gtfeWord().beamMode() == theBeamShoutMode) shoutMODE=true;
  }
  else{
    shoutMODE=true;
  }

  // get scalar collection
  Handle<BeamSpotOnlineCollection> handleScaler;
  iEvent.getByToken( scalerToken_, handleScaler);

  // beam spot scalar object
  BeamSpotOnline spotOnline;

  // product is a reco::BeamSpot object
  auto result = std::make_unique<reco::BeamSpot>();
  
  reco::BeamSpot aSpot;

  bool fallBackToDB=false;
  if (handleScaler->size()!=0){
    // get one element
    spotOnline = * ( handleScaler->begin() );
    
    // in case we need to switch to LHC reference frame
    // ignore for the moment rotations, and translations
    double f = 1.;
    if (changeFrame_) f = -1.;
    
    reco::BeamSpot::Point apoint( f* spotOnline.x(), spotOnline.y(), f* spotOnline.z() );
    
    reco::BeamSpot::CovarianceMatrix matrix;
    matrix(0,0) = spotOnline.err_x()*spotOnline.err_x();
    matrix(1,1) = spotOnline.err_y()*spotOnline.err_y();
    matrix(2,2) = spotOnline.err_z()*spotOnline.err_z();
    matrix(3,3) = spotOnline.err_sigma_z()*spotOnline.err_sigma_z();
    
    double sigmaZ = spotOnline.sigma_z();
    if (theSetSigmaZ>0)
      sigmaZ = theSetSigmaZ;
    
    aSpot = reco::BeamSpot( apoint,
                sigmaZ,
                spotOnline.dxdz(),
                f* spotOnline.dydz(),
                spotOnline.width_x(),
                matrix);
    
    aSpot.setBeamWidthY( spotOnline.width_y() );
    aSpot.setEmittanceX( 0. );
    aSpot.setEmittanceY( 0. );
    aSpot.setbetaStar( 0.) ;
    aSpot.setType( reco::BeamSpot::LHC ); // flag value from scalars
    
    // check if we have a valid beam spot fit result from online DQM
    if ( spotOnline.x() == 0 &&
     spotOnline.y() == 0 &&
     spotOnline.z() == 0 &&
     spotOnline.width_x() == 0 &&
     spotOnline.width_y() == 0 ) 
      {
    if (shoutMODE){
      edm::LogWarning("BeamSpotFromDB") 
      << "Online Beam Spot producer falls back to DB value because the scaler values are zero ";
    }
    fallBackToDB=true;
      }
    double r2=spotOnline.x()*spotOnline.x() + spotOnline.y()*spotOnline.y();
    if (fabs(spotOnline.z())>=theMaxZ || r2>=theMaxR2){
      if (shoutMODE){
    edm::LogError("BeamSpotFromDB") 
      << "Online Beam Spot producer falls back to DB value because the scaler values are too big to be true :"
      <<spotOnline.x()<<" "<<spotOnline.y()<<" "<<spotOnline.z();
      }
      fallBackToDB=true;
    }
  }
  else{
    //empty online beamspot collection: FED data was empty
    //the error should probably have been send at unpacker level
    fallBackToDB=true;
  }
      
  if (fallBackToDB){

    edm::ESHandle< BeamSpotObjects > beamhandle;
    iSetup.get<BeamSpotObjectsRcd>().get(beamhandle);
    const BeamSpotObjects *spotDB = beamhandle.product();

    // translate from BeamSpotObjects to reco::BeamSpot
    reco::BeamSpot::Point apoint( spotDB->GetX(), spotDB->GetY(), spotDB->GetZ() );
  
    reco::BeamSpot::CovarianceMatrix matrix;
    for ( int i=0; i<7; ++i ) {
      for ( int j=0; j<7; ++j ) {
    matrix(i,j) = spotDB->GetCovariance(i,j);
      }
    }
  
    // this assume beam width same in x and y
    aSpot = reco::BeamSpot( apoint,
                spotDB->GetSigmaZ(),
                spotDB->Getdxdz(),
                spotDB->Getdydz(),
                spotDB->GetBeamWidthX(),
                matrix );
    aSpot.setBeamWidthY( spotDB->GetBeamWidthY() );
    aSpot.setEmittanceX( spotDB->GetEmittanceX() );
    aSpot.setEmittanceY( spotDB->GetEmittanceY() );
    aSpot.setbetaStar( spotDB->GetBetaStar() );
    aSpot.setType( reco::BeamSpot::Tracker );

  }
  
  *result = aSpot;

  iEvent.put(std::move(result));

}

DEFINE_FWK_MODULE(BeamSpotOnlineProducer);