TtEvtBuilder.h

Go to the documentation of this file.

#ifndef TtEvtBuilder_h
#define TtEvtBuilder_h

#include <vector>

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/transform.h"
#include "AnalysisDataFormats/TopObjects/interface/TtEvent.h"

template <typename C>
class TtEvtBuilder : public edm::EDProducer {

 public:

  explicit TtEvtBuilder(const edm::ParameterSet&);
  ~TtEvtBuilder(){};

 private:

  virtual void produce(edm::Event&, const edm::EventSetup&);
  virtual void fillSpecific(C&, const edm::Event&);

 private:

  int verbosity_;
  std::vector<edm::EDGetTokenT<int> > hypKeyTokens_;
  std::vector<edm::EDGetTokenT<std::vector<TtEvent::HypoCombPair> > > hypTokens_;
  std::vector<edm::EDGetTokenT<int> > hypNeutrTokens_;
  std::vector<edm::EDGetTokenT<int> > hypJetTokens_;
  typedef std::vector<edm::EDGetTokenT<int> >::const_iterator EventHypoIntToken;
  typedef std::vector<edm::EDGetTokenT<std::vector<TtEvent::HypoCombPair> > >::const_iterator EventHypoToken;
  edm::InputTag genEvt_;
  edm::EDGetTokenT<TtGenEvent> genEvtToken_;
  int decayChnTop1_;
  int decayChnTop2_;

  edm::ParameterSet kinFit_;
  edm::EDGetTokenT<std::vector<double> > fitChi2Token_;
  edm::EDGetTokenT<std::vector<double> > fitProbToken_;
  edm::ParameterSet hitFit_;
  edm::EDGetTokenT<std::vector<double> > hitFitChi2Token_;
  edm::EDGetTokenT<std::vector<double> > hitFitProbToken_;
  edm::EDGetTokenT<std::vector<double> > hitFitMTToken_;
  edm::EDGetTokenT<std::vector<double> > hitFitSigMTToken_;
  edm::ParameterSet kinSolution_;
  edm::EDGetTokenT<std::vector<double> > solWeightToken_;
  edm::EDGetTokenT<bool> wrongChargeToken_;
  edm::ParameterSet genMatch_;
  edm::EDGetTokenT<std::vector<double> > sumPtToken_;
  edm::EDGetTokenT<std::vector<double> > sumDRToken_;
  edm::ParameterSet mvaDisc_;
  edm::EDGetTokenT<std::string> methToken_;
  edm::EDGetTokenT<std::vector<double> > discToken_;
};

template <typename C>
TtEvtBuilder<C>::TtEvtBuilder(const edm::ParameterSet& cfg) :
  verbosity_   (cfg.getParameter<int>                        ("verbosity"    )),
  hypKeyTokens_        (edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("hypotheses"   ), [this](edm::InputTag const & tag){return consumes<int>(edm::InputTag(tag.label(), "Key"));})),
  hypTokens_        (edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("hypotheses"   ), [this](edm::InputTag const & tag){return consumes<std::vector<TtEvent::HypoCombPair> >(tag);})),
  hypNeutrTokens_        (edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("hypotheses"   ), [this](edm::InputTag const & tag){return consumes<int>(edm::InputTag(tag.label(), "NumberOfRealNeutrinoSolutions"));})),
  hypJetTokens_        (edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("hypotheses"   ), [this](edm::InputTag const & tag){return consumes<int>(edm::InputTag(tag.label(), "NumberOfConsideredJets"));})),
  genEvt_      (cfg.getParameter<edm::InputTag>              ("genEvent"     )),
  genEvtToken_      (mayConsume<TtGenEvent>(genEvt_)),
  decayChnTop1_(cfg.getParameter<int>                        ("decayChannel1")),
  decayChnTop2_(cfg.getParameter<int>                        ("decayChannel2"))
{
  // parameter subsets for kKinFit
  if( cfg.exists("kinFit") ) {
    kinFit_  = cfg.getParameter<edm::ParameterSet>("kinFit");
    fitChi2Token_ = mayConsume<std::vector<double> >(kinFit_.getParameter<edm::InputTag>("chi2"));
    fitProbToken_ = mayConsume<std::vector<double> >(kinFit_.getParameter<edm::InputTag>("prob"));
  }
  // parameter subsets for kHitFit
  if( cfg.exists("hitFit") ) {
    hitFit_  = cfg.getParameter<edm::ParameterSet>("hitFit");
    hitFitChi2Token_ = mayConsume<std::vector<double> >(hitFit_.getParameter<edm::InputTag>("chi2"));
    hitFitProbToken_ = mayConsume<std::vector<double> >(hitFit_.getParameter<edm::InputTag>("prob"));
    hitFitMTToken_ = mayConsume<std::vector<double> >(hitFit_.getParameter<edm::InputTag>("mt"));
    hitFitSigMTToken_ = mayConsume<std::vector<double> >(hitFit_.getParameter<edm::InputTag>("sigmt"));
  }
  // parameter subsets for kKinSolution
  if( cfg.exists("kinSolution") ) {
    kinSolution_  = cfg.getParameter<edm::ParameterSet>("kinSolution");
    solWeightToken_    = mayConsume<std::vector<double> >(kinSolution_.getParameter<edm::InputTag>("solWeight"));
    wrongChargeToken_  = mayConsume<bool>(kinSolution_.getParameter<edm::InputTag>("wrongCharge"));
  }
  // parameter subsets for kGenMatch
  if( cfg.exists("genMatch") ) {
    genMatch_ = cfg.getParameter<edm::ParameterSet>("genMatch");
    sumPtToken_    = mayConsume<std::vector<double> >(genMatch_.getParameter<edm::InputTag>("sumPt"));
    sumDRToken_    = mayConsume<std::vector<double> >(genMatch_.getParameter<edm::InputTag>("sumDR"));
  }
  // parameter subsets for kMvaDisc
  if( cfg.exists("mvaDisc") ) {
    mvaDisc_ = cfg.getParameter<edm::ParameterSet>("mvaDisc");
    methToken_    = mayConsume<std::string>(mvaDisc_.getParameter<edm::InputTag>("meth"));
    discToken_    = mayConsume<std::vector<double> >(mvaDisc_.getParameter<edm::InputTag>("disc"));
  }
  // produces a TtEventEvent for:
  //  * TtSemiLeptonicEvent
  //  * TtFullLeptonicEvent
  //  * TtFullHadronicEvent
  // from hypotheses and associated extra information
  produces<C>();
}

template <typename C>
void
TtEvtBuilder<C>::produce(edm::Event& evt, const edm::EventSetup& setup)
{
  C ttEvent;

  // set leptonic decay channels
  ttEvent.setLepDecays( WDecay::LeptonType(decayChnTop1_), WDecay::LeptonType(decayChnTop2_) );

  // set genEvent (if available)
  edm::Handle<TtGenEvent> genEvt;
  if ( genEvt_.label().size() > 0 )
    if( evt.getByToken(genEvtToken_, genEvt) )
      ttEvent.setGenEvent(genEvt);

  // add event hypotheses for all given
  // hypothesis classes to the TtEvent
  EventHypoIntToken hKey = hypKeyTokens_.begin();
  EventHypoToken h = hypTokens_.begin();
  for( ; hKey != hypKeyTokens_.end(); ++hKey, ++h){
    edm::Handle<int> key;
    evt.getByToken(*hKey, key);

    edm::Handle<std::vector<TtEvent::HypoCombPair> > hypMatchVec;
    evt.getByToken(*h, hypMatchVec);

    typedef std::vector<TtEvent::HypoCombPair>::const_iterator HypMatch;
    for(HypMatch hm=hypMatchVec->begin(); hm != hypMatchVec->end(); ++hm){
      ttEvent.addEventHypo((TtEvent::HypoClassKey&)*key, *hm);
    }
  }

  // set kKinFit extras
  if( ttEvent.isHypoAvailable(TtEvent::kKinFit) ) {
    edm::Handle<std::vector<double> > fitChi2;
    evt.getByToken(fitChi2Token_, fitChi2);
    ttEvent.setFitChi2( *fitChi2 );

    edm::Handle<std::vector<double> > fitProb;
    evt.getByToken(fitProbToken_, fitProb);
    ttEvent.setFitProb( *fitProb );
  }

  // set kHitFit extras
  if( ttEvent.isHypoAvailable(TtEvent::kHitFit) ) {
    edm::Handle<std::vector<double> > hitFitChi2;
    evt.getByToken(hitFitChi2Token_, hitFitChi2);
    ttEvent.setHitFitChi2( *hitFitChi2 );

    edm::Handle<std::vector<double> > hitFitProb;
    evt.getByToken(hitFitProbToken_, hitFitProb);
    ttEvent.setHitFitProb( *hitFitProb );

    edm::Handle<std::vector<double> > hitFitMT;
    evt.getByToken(hitFitMTToken_, hitFitMT);
    ttEvent.setHitFitMT( *hitFitMT );

    edm::Handle<std::vector<double> > hitFitSigMT;
    evt.getByToken(hitFitSigMTToken_, hitFitSigMT);
    ttEvent.setHitFitSigMT( *hitFitSigMT );
  }

  // set kGenMatch extras
  if( ttEvent.isHypoAvailable(TtEvent::kGenMatch) ) {
    edm::Handle<std::vector<double> > sumPt;
    evt.getByToken(sumPtToken_, sumPt);
    ttEvent.setGenMatchSumPt( *sumPt );

    edm::Handle<std::vector<double> > sumDR;
    evt.getByToken(sumDRToken_, sumDR);
    ttEvent.setGenMatchSumDR( *sumDR );
  }

  // set kMvaDisc extras
  if( ttEvent.isHypoAvailable(TtEvent::kMVADisc) ) {
    edm::Handle<std::string> meth;
    evt.getByToken(methToken_, meth);
    ttEvent.setMvaMethod( *meth );

    edm::Handle<std::vector<double> > disc;
    evt.getByToken(discToken_, disc);
    ttEvent.setMvaDiscriminators( *disc );
  }

  // fill data members that are decay-channel specific
  fillSpecific(ttEvent, evt);

  // print summary via MessageLogger if verbosity_>0
  ttEvent.print(verbosity_);

  // write object into the edm::Event
  std::unique_ptr<C> pOut(new C);
  *pOut=ttEvent;
  evt.put(std::move(pOut));
}

template <>
void TtEvtBuilder<TtFullHadronicEvent>::fillSpecific(TtFullHadronicEvent& ttEvent, const edm::Event& evt)
{
}

template <>
void TtEvtBuilder<TtFullLeptonicEvent>::fillSpecific(TtFullLeptonicEvent& ttEvent, const edm::Event& evt)
{

  // set kKinSolution extras
  if( ttEvent.isHypoAvailable(TtEvent::kKinSolution) ) {
    edm::Handle<std::vector<double> > solWeight;
    evt.getByToken(solWeightToken_, solWeight);
    ttEvent.setSolWeight( *solWeight );

    edm::Handle<bool> wrongCharge;
    evt.getByToken(wrongChargeToken_, wrongCharge);
    ttEvent.setWrongCharge( *wrongCharge );
  }

}

template <>
void TtEvtBuilder<TtSemiLeptonicEvent>::fillSpecific(TtSemiLeptonicEvent& ttEvent, const edm::Event& evt)
{

  EventHypoIntToken hKey = hypKeyTokens_.begin();
  EventHypoIntToken hNeutr = hypNeutrTokens_.begin();
  EventHypoIntToken hJet = hypJetTokens_.begin();
  for( ; hKey != hypKeyTokens_.end(); ++hKey, ++hNeutr, ++hJet){
    edm::Handle<int> key;
    evt.getByToken(*hKey, key);

    // set number of real neutrino solutions for all hypotheses
    edm::Handle<int> numberOfRealNeutrinoSolutions;
    evt.getByToken(*hNeutr, numberOfRealNeutrinoSolutions);
    ttEvent.setNumberOfRealNeutrinoSolutions((TtEvent::HypoClassKey&)*key, *numberOfRealNeutrinoSolutions);

    // set number of considered jets for all hypotheses
    edm::Handle<int> numberOfConsideredJets;
    evt.getByToken(*hJet, numberOfConsideredJets);
    ttEvent.setNumberOfConsideredJets((TtEvent::HypoClassKey&)*key, *numberOfConsideredJets);
  }

}

#endif