PileupVertexAccumulator.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    PileupVertexAccumulator
// Class:      PileupVertexAccumulator
//
//
// Original Author: Mike Hildreth - Notre Dame
//         Created:  Wed Jan 21 05:14:48 CET 2015
//
//
 
// system include files
#include <memory>
#include <set>
 
// user include files
#include "PileupVertexAccumulator.h"
 
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
 
#include "SimDataFormats/GeneratorProducts/interface/GenRunInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "SimDataFormats/PileupSummaryInfo/interface/PileupVertexContent.h"
 
// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
 
#include "FWCore/Utilities/interface/StreamID.h"
#include "FWCore/Utilities/interface/Exception.h"
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
 
//
// constructors and destructor
//
//using namespace std;
 
namespace cms {
  PileupVertexAccumulator::PileupVertexAccumulator(const edm::ParameterSet& iConfig,
                                                   edm::ProducesCollector producesCollector,
                                                   edm::ConsumesCollector& iC)
      : Mtag_(iConfig.getParameter<edm::InputTag>("vtxTag")),
        fallbackMtag_(iConfig.getParameter<edm::InputTag>("vtxFallbackTag")),
        saveVtxTimes_(iConfig.getParameter<bool>("saveVtxTimes")) {
    edm::LogInfo("PixelDigitizer ") << "Enter the Pixel Digitizer";
 
    const std::string alias("PileupVertexAccum");
 
    producesCollector.produces<PileupVertexContent>().setBranchAlias(alias);
 
    iC.consumes<edm::HepMCProduct>(Mtag_);
    iC.mayConsume<edm::HepMCProduct>(fallbackMtag_);
  }
 
  PileupVertexAccumulator::~PileupVertexAccumulator() {}
 
  //
  // member functions
  //
 
  void PileupVertexAccumulator::initializeEvent(edm::Event const& e, edm::EventSetup const& iSetup) {
    // Make sure that the first crossing processed starts indexing the minbias events from zero.
 
    pT_Hats_.clear();
    z_posns_.clear();
    t_posns_.clear();
  }
 
  void PileupVertexAccumulator::accumulate(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
    // don't do anything for hard-scatter signal events
  }
 
  void PileupVertexAccumulator::accumulate(PileUpEventPrincipal const& iEvent,
                                           edm::EventSetup const& iSetup,
                                           edm::StreamID const& streamID) {
    edm::Handle<edm::HepMCProduct> MCevt;
    iEvent.getByLabel(Mtag_, MCevt);
    if (MCevt.whyFailed()) {
      iEvent.getByLabel(fallbackMtag_, MCevt);
    }
 
    const HepMC::GenEvent* myGenEvent = MCevt->GetEvent();
 
    double pthat = myGenEvent->event_scale();
    float pt_hat = float(pthat);
 
    pT_Hats_.push_back(pt_hat);
 
    HepMC::GenEvent::vertex_const_iterator viter;
    HepMC::GenEvent::vertex_const_iterator vbegin = myGenEvent->vertices_begin();
    HepMC::GenEvent::vertex_const_iterator vend = myGenEvent->vertices_end();
 
    // for production point, pick first vertex
    viter = vbegin;
 
    if (viter != vend) {
      // The origin vertex (turn it to cm's from GenEvent mm's)
      HepMC::GenVertex* v = *viter;
      float zpos = v->position().z() * 0.1;
 
      z_posns_.push_back(zpos);
 
      if (saveVtxTimes_) {
        float tpos = v->position().t() / 299792458e-6;  // turn from mm to ns
        t_posns_.push_back(tpos);
      }
    }
 
    //    delete myGenEvent;
  }
 
  // ------------ method called to produce write the data  ------------
  void PileupVertexAccumulator::finalizeEvent(edm::Event& iEvent, const edm::EventSetup& iSetup) {
    std::unique_ptr<PileupVertexContent> PUVtxC(new PileupVertexContent(pT_Hats_, z_posns_, t_posns_));
 
    // write output to event
    iEvent.put(std::move(PUVtxC));
  }
 
}  // namespace cms