JetMatchingHook.cc

Go to the documentation of this file.

#include "GeneratorInterface/Pythia8Interface/plugins/JetMatchingHook.h"
#include "GeneratorInterface/PartonShowerVeto/interface/JetMatchingMadgraph.h"
#include "GeneratorInterface/PartonShowerVeto/interface/JetMatchingMGFastJet.h"
 
#include "FWCore/Utilities/interface/Exception.h"
 
//#include "HepMC/HEPEVT_Wrapper.h"
#include <cassert>
 
#include "GeneratorInterface/Pythia8Interface/plugins/Py8toJetInput.h"
 
extern "C" {
// this is patchup for Py6 common block because
// several elements of the VINT array are used in the matching process
 
extern struct {
  int mint[400];
  double vint[400];
} pyint1_;
}
 
using namespace gen;
using namespace Pythia8;
 
JetMatchingHook::JetMatchingHook(const edm::ParameterSet& ps, const Info* info)
    : UserHooks(),
      fRunBlock(nullptr),
      fEventBlock(nullptr),
      fEventNumber(0),
//      fInfoPtr(info),
      fJetMatching(nullptr),
      fJetInputFill(nullptr),
      fIsInitialized(false) {
//  assert(fInfoPtr);
 
  std::string scheme = ps.getParameter<std::string>("scheme");
 
  if (scheme == "Madgraph") {
    fJetMatching = new JetMatchingMadgraph(ps);
    fJetInputFill = new Py8toJetInputHEPEVT();
  } else if (scheme == "MadgraphFastJet") {
    fJetMatching = new JetMatchingMGFastJet(ps);
    fJetInputFill = new Py8toJetInput();
  } else if (scheme == "MLM" || scheme == "Alpgen") {
    throw cms::Exception("JetMatching") << "Port of " << scheme << "scheme \""
                                        << "\""
                                           " for parton-shower matching is still in progress."
                                        << std::endl;
  } else
    throw cms::Exception("InvalidJetMatching") << "Unknown scheme \"" << scheme
                                               << "\""
                                                  " specified for parton-shower matching."
                                               << std::endl;
}
 
JetMatchingHook::~JetMatchingHook() {
  if (fJetMatching)
    delete fJetMatching;
}
 
void JetMatchingHook::init(lhef::LHERunInfo* runInfo) {
  setLHERunInfo(runInfo);
  if (!fRunBlock) {
    throw cms::Exception("JetMatching") << "Invalid RunInfo" << std::endl;
  }
  fJetMatching->init(runInfo);
  double etaMax = fJetMatching->getJetEtaMax();
  fJetInputFill->setJetEtaMax(etaMax);
  return;
}
 
void JetMatchingHook::beforeHadronization(lhef::LHEEvent* lhee) {
  setLHEEvent(lhee);
  fJetMatching->beforeHadronisation(lhee);
 
  // here we'll have to adjust, if needed, for "massless" particles
  // from earlier Madgraph version(s)
  // also, we'll have to setup elements of the Py6 fortran array
  // VINT(357), VINT(358), VINT(360) and VINT(390)
  // if ( fJetMatching->getMatchingScheme() == "Madgraph" )
  // {
  //
  // }
 
  fJetMatching->beforeHadronisationExec();
 
  return;
}
 
bool JetMatchingHook::doVetoPartonLevel(const Event& event)
// JetMatchingHook::doVetoPartonLevelEarly( const Event& event )
{
  // event.list();
 
  // extract "hardest" event - the output will go into workEvent,
  // which is a data mamber of base class UserHooks
  //
  subEvent(event, true);
 
  if (!hepeup_.nup || fJetMatching->isMatchingDone()) {
    return true;
  }
 
  //
  // bool jmtch = fJetMatching->match( 0, 0, true ); // true if veto-ed, false if accepted (not veto-ed)
  std::vector<fastjet::PseudoJet> jetInput =
      fJetInputFill->fillJetAlgoInput(event, workEvent, fEventBlock, fJetMatching->getPartonList());
  bool jmtch = fJetMatching->match(fEventBlock, &jetInput);
  if (jmtch) {
    return true;
  }
 
  // Do not veto events that got this far
  //
  return false;
}