gen::JetMatchingMGFastJet Class Reference

#include <JetMatchingMGFastJet.h>

Inheritance diagram for gen::JetMatchingMGFastJet:

Public Member Functions
const std::vector< int > *	getPartonList () override
	JetMatchingMGFastJet (const edm::ParameterSet &params)
template<>
std::string	parseParameter (const std::string &value)
template<>
bool	parseParameter (const std::string &value_)
	~JetMatchingMGFastJet () override
Public Member Functions inherited from gen::JetMatching
virtual std::set< std::string >	capabilities () const
bool	isMatchingDone ()
	JetMatching (const edm::ParameterSet &params)
void	resetMatchingStatus ()
virtual	~JetMatching ()

Protected Member Functions
void	beforeHadronisation (const lhef::LHEEvent *) override
void	beforeHadronisationExec () override
double	getJetEtaMax () const override
void	init (const lhef::LHERunInfo *runInfo) override
bool	initAfterBeams () override
int	match (const lhef::LHEEvent *partonLevel, const std::vector< fastjet::PseudoJet > *jetInput) override

Private Types
enum	partonTypes { ID_TOP = 6, ID_GLUON = 21, ID_PHOTON = 22 }
enum	vetoStatus {   NONE, LESS_JETS, MORE_JETS, HARD_JET,   UNMATCHED_PARTON }

Private Member Functions
template<typename T >
T	getParameter (const std::string &var, const T &defValue=T()) const

Static Private Member Functions
template<typename T >
static T	getParameter (const std::map< std::string, std::string > &params, const std::string &var, const T &defValue=T())
template<typename T >
static T	parseParameter (const std::string &value)
template<typename T >
static void	updateOrDie (const std::map< std::string, std::string > &params, T &param, const std::string &name)

Private Attributes
double	clFact
double	coneRadius
bool	doMerge
double	etaJetMax
bool	exclusive
std::vector< fastjet::PseudoJet >	fClusJets
int	fDJROutFlag
std::ofstream	fDJROutput
bool	fExcLocal
bool	fIsInit
fastjet::JetDefinition *	fJetFinder
std::vector< fastjet::PseudoJet >	fPtSortedJets
int	jetAlgoPower
std::map< std::string, std::string >	mgParams
int	nJetMax
int	nJetMin
int	nQmatch
double	qCut
double	qCutSq
bool	runInitialized
bool	soup
std::vector< int >	typeIdx [3]

Additional Inherited Members
Static Public Member Functions inherited from gen::JetMatching
static std::unique_ptr< JetMatching >	create (const edm::ParameterSet &params)
Protected Attributes inherited from gen::JetMatching
bool	fMatchingStatus

Detailed Description

Definition at line 31 of file JetMatchingMGFastJet.h.

Member Enumeration Documentation

partonTypes

enum gen::JetMatchingMGFastJet::partonTypes

private

Enumerator
ID_TOP
ID_GLUON
ID_PHOTON

Definition at line 73 of file JetMatchingMGFastJet.h.

{ ID_TOP = 6, ID_GLUON = 21, ID_PHOTON = 22 };

vetoStatus

enum gen::JetMatchingMGFastJet::vetoStatus

private

Enumerator
NONE
LESS_JETS
MORE_JETS
HARD_JET
UNMATCHED_PARTON

Definition at line 72 of file JetMatchingMGFastJet.h.

{ NONE, LESS_JETS, MORE_JETS, HARD_JET, UNMATCHED_PARTON };

Constructor & Destructor Documentation

JetMatchingMGFastJet()

gen::JetMatchingMGFastJet::JetMatchingMGFastJet

(

const edm::ParameterSet &

params

)

Definition at line 127 of file JetMatchingMGFastJet.cc.

References gen::MEMAIN::clfact, gen::MEMAIN::etaclmax, gen::MEMAIN::etcjet, Exception, exclusive, gen::MEMAIN::excres, fDJROutFlag, gen::OUTTREE::flag, B2GTnPMonitor_cfi::item, gen::MEMAIN::ktsche, gen::MEMAIN::maxjets, gen::memain_, gen::MEMAIN::minjets, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, gen::MEMAIN::nexcres, gen::MEMAIN::nqmatch, gen::outtree_, submitPVValidationJobs::params, gen::MEMAIN::qcut, gen::MEMAIN::rclmax, gen::MEMAIN::showerkt, soup, contentValuesCheck::ss, and AlCaHLTBitMon_QueryRunRegistry::string.

      : JetMatching(params), runInitialized(false), fJetFinder(nullptr), fIsInit(false) {
    std::string mode = params.getParameter<std::string>("mode");
    if (mode == "inclusive") {
      soup = false;
      exclusive = false;
    } else if (mode == "exclusive") {
      soup = false;
      exclusive = true;
    } else if (mode == "auto")
      soup = true;
    else
      throw cms::Exception("Generator|LHEInterface") << "MGFastJet jet matching scheme requires \"mode\" "
                                                        "parameter to be set to either \"inclusive\", "
                                                        "\"exclusive\" or \"auto\"."
                                                     << std::endl;

    memain_.etcjet = 0.;
    memain_.rclmax = 0.0;
    memain_.clfact = 0.0;
    memain_.ktsche = 0.0;
    memain_.etaclmax = params.getParameter<double>("MEMAIN_etaclmax");
    memain_.qcut = params.getParameter<double>("MEMAIN_qcut");
    memain_.minjets = params.getParameter<int>("MEMAIN_minjets");
    memain_.maxjets = params.getParameter<int>("MEMAIN_maxjets");
    memain_.showerkt = params.getParameter<double>("MEMAIN_showerkt");
    memain_.nqmatch = params.getParameter<int>("MEMAIN_nqmatch");
    outtree_.flag = params.getParameter<int>("outTree_flag");
    std::string list_excres = params.getParameter<std::string>("MEMAIN_excres");
    std::vector<std::string> elems;
    std::stringstream ss(list_excres);
    std::string item;
    int index = 0;
    while (std::getline(ss, item, ',')) {
      elems.push_back(item);
      memain_.excres[index] = std::atoi(item.c_str());
      index++;
    }
    memain_.nexcres = index;

    fDJROutFlag = params.getParameter<int>("outTree_flag");
  }

~JetMatchingMGFastJet()

gen::JetMatchingMGFastJet::~JetMatchingMGFastJet ( )

inlineoverride

Definition at line 35 of file JetMatchingMGFastJet.h.

References fJetFinder.

                                     {
      if (fJetFinder)
        delete fJetFinder;
    }

Member Function Documentation

beforeHadronisation()

void gen::JetMatchingMGFastJet::beforeHadronisation ( const lhef::LHEEvent *  lhee )

overrideprotectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 213 of file JetMatchingMGFastJet.cc.

References funct::abs(), Exception, exclusive, fExcLocal, lhef::LHEEvent::getHEPEUP(), mps_fire::i, ID_GLUON, ID_TOP, lhef::HEPEUP::IDUP, heavyIonCSV_trainingSettings::idx, lhef::HEPEUP::ISTUP, lhef::HEPEUP::MOTHUP, nJetMax, nQmatch, lhef::HEPEUP::NUP, runInitialized, soup, and typeIdx.

                                                                         {
    if (!runInitialized)
      throw cms::Exception("Generator|PartonShowerVeto") << "Run not initialized in JetMatchingMGFastJet" << std::endl;

    for (int i = 0; i < 3; i++) {
      typeIdx[i].clear();
    }

    // Sort original process final state into light/heavy jets and 'other'.
    // Criteria:
    //   1 <= ID <= 5 and massless, or ID == 21 --> light jet (typeIdx[0])
    //   4 <= ID <= 6 and massive               --> heavy jet (typeIdx[1])
    //   All else                               --> other     (typeIdx[2])
    //
    const lhef::HEPEUP &hepeup = *lhee->getHEPEUP();
    int idx = 2;
    for (int i = 0; i < hepeup.NUP; i++) {
      if (hepeup.ISTUP[i] < 0)
        continue;
      if (hepeup.MOTHUP[i].first != 1 && hepeup.MOTHUP[i].second != 2)
        continue;  // this way we skip entries that come
                   // from resonance decays;
                   // we only take those that descent
                   // directly from "incoming partons"
      idx = 2;
      if (hepeup.IDUP[i] == ID_GLUON || (std::abs(hepeup.IDUP[i]) <= nQmatch))  // light jet
                                                                                // light jet
        idx = 0;
      else if (std::abs(hepeup.IDUP[i]) > nQmatch && std::abs(hepeup.IDUP[i]) <= ID_TOP)  // heavy jet
        idx = 1;
      // Store
      typeIdx[idx].push_back(i);
    }

    // NOTE: In principle, I should use exclusive, inclusive, or soup !!!
    // should be like this:
    if (soup) {
      int NPartons = typeIdx[0].size();
      fExcLocal = (NPartons < nJetMax);
    } else
      fExcLocal = exclusive;

    return;
  }

beforeHadronisationExec()

void gen::JetMatchingMGFastJet::beforeHadronisationExec ( )

inlineoverrideprotectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 47 of file JetMatchingMGFastJet.h.

{ return; }

getJetEtaMax()

double gen::JetMatchingMGFastJet::getJetEtaMax ( ) const

overrideprotectedvirtual

Implements gen::JetMatching.

Definition at line 170 of file JetMatchingMGFastJet.cc.

References gen::MEMAIN::etaclmax, and gen::memain_.

{ return memain_.etaclmax; }

getParameter() [1/2]

template<typename T >

T gen::JetMatchingMGFastJet::getParameter ( const std::map< std::string, std::string > &  params, const std::string &  var, const T &  defValue = T()  )

staticprivate

Definition at line 72 of file JetMatchingMGFastJet.cc.

References submitPVValidationJobs::params, and trigObjTnPSource_cfi::var.

Referenced by getParameter(), and updateOrDie().

                                                          {
    std::map<std::string, std::string>::const_iterator pos = params.find(var);
    if (pos == params.end())
      return defValue;
    return parseParameter<T>(pos->second);
  }

getParameter() [2/2]

template<typename T >

T gen::JetMatchingMGFastJet::getParameter ( const std::string &  var, const T &  defValue = T()  ) const

private

Definition at line 82 of file JetMatchingMGFastJet.cc.

References getParameter(), mgParams, and trigObjTnPSource_cfi::var.

                                                                                    {
    return getParameter(mgParams, var, defValue);
  }

getPartonList()

const std::vector<int>* gen::JetMatchingMGFastJet::getPartonList ( )

inlineoverridevirtual

Reimplemented from gen::JetMatching.

Definition at line 40 of file JetMatchingMGFastJet.h.

References typeIdx.

{ return typeIdx; }

init()

void gen::JetMatchingMGFastJet::init ( const lhef::LHERunInfo *  runInfo )

overrideprotectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 258 of file JetMatchingMGFastJet.cc.

References gather_cfg::cout, gen::MEMAIN::etaclmax, fIsInit, RecoTauValidation_cfi::header, gen::UPPRIV::ickkw, initAfterBeams(), gen::MEMAIN::maxjets, gen::MEMAIN::mektsc, gen::memain_, mgParams, gen::MEMAIN::minjets, gen::MEMAIN::nqmatch, submitPVValidationJobs::params, gen::parseHeader(), gen::MEMAIN::qcut, submitPVValidationJobs::runInfo, runInitialized, gen::MEMAIN::showerkt, updateOrDie(), gen::uppriv_, and contentValuesCheck::values.

                                                               {
    if (fIsInit)
      return;

    // read MGFastJet run card

    std::map<std::string, std::string> parameters;

    std::vector<std::string> header = runInfo->findHeader("MGRunCard");
    if (header.empty())
      throw cms::Exception("Generator|PartonShowerVeto") << "In order to use MGFastJet jet matching, "
                                                            "the input file has to contain the corresponding "
                                                            "MadGraph headers."
                                                         << std::endl;

    mgParams = parseHeader(header);

    // set variables in common block

    std::vector<Param> params;
    std::vector<Param> values;
    for (std::map<std::string, std::string>::const_iterator iter = mgParams.begin(); iter != mgParams.end(); ++iter) {
      params.push_back(" " + iter->first);
      values.push_back(iter->second);
    }

    // set MG matching parameters

    uppriv_.ickkw = getParameter<int>("ickkw", 0);
    memain_.mektsc = getParameter<int>("ktscheme", 0);

    header = runInfo->findHeader("MGParamCMS");

    std::map<std::string, std::string> mgInfoCMS = parseHeader(header);

    for (std::map<std::string, std::string>::const_iterator iter = mgInfoCMS.begin(); iter != mgInfoCMS.end(); ++iter) {
      std::cout << "mgInfoCMS: " << iter->first << " " << iter->second << std::endl;
    }

    updateOrDie(mgInfoCMS, memain_.etaclmax, "etaclmax");
    updateOrDie(mgInfoCMS, memain_.qcut, "qcut");
    updateOrDie(mgInfoCMS, memain_.minjets, "minjets");
    updateOrDie(mgInfoCMS, memain_.maxjets, "maxjets");
    updateOrDie(mgInfoCMS, memain_.showerkt, "showerkt");
    updateOrDie(mgInfoCMS, memain_.nqmatch, "nqmatch");

    runInitialized = true;

    initAfterBeams();

    fIsInit = true;

    return;
  }

initAfterBeams()

bool gen::JetMatchingMGFastJet::initAfterBeams ( )

overrideprotectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 172 of file JetMatchingMGFastJet.cc.

References clFact, coneRadius, doMerge, gen::MEMAIN::etaclmax, etaJetMax, fClusJets, fExcLocal, fIsInit, fJetFinder, fPtSortedJets, gen::UPPRIV::ickkw, jetAlgoPower, gen::MEMAIN::maxjets, gen::memain_, gen::MEMAIN::minjets, nJetMax, nJetMin, gen::MEMAIN::nqmatch, nQmatch, funct::pow(), gen::MEMAIN::qcut, qCut, qCutSq, and gen::uppriv_.

Referenced by init().

                                            {
    if (fIsInit)
      return true;

    //
    doMerge = uppriv_.ickkw;
    // doMerge = true;
    qCut = memain_.qcut;  //
    nQmatch = memain_.nqmatch;
    clFact = 1.;  // Default value
                  // NOTE: ME2pythia seems to default to 1.5 - need to check !!!
                  // in general, needs to read key ALPSFACT from LHE file - fix CMSSW code !!!
    nJetMin = memain_.minjets;
    nJetMax = memain_.maxjets;

    etaJetMax = memain_.etaclmax;

    coneRadius = 1.0;
    jetAlgoPower = 1;  //   this is the kT algorithm !!!

    // Matching procedure
    //
    qCutSq = pow(qCut, 2);
    // this should be something like memaev_.iexc
    fExcLocal = true;

    // If not merging, then done (?????)
    //
    // if (!doMerge) return true;

    // Initialise chosen jet algorithm.
    //
    fJetFinder = new fastjet::JetDefinition(fastjet::kt_algorithm, coneRadius);
    fClusJets.clear();
    fPtSortedJets.clear();

    fIsInit = true;

    return true;
  }

match()

int gen::JetMatchingMGFastJet::match ( const lhef::LHEEvent *  partonLevel, const std::vector< fastjet::PseudoJet > *  jetInput  )

overrideprotectedvirtual

Implements gen::JetMatching.

Definition at line 313 of file JetMatchingMGFastJet.cc.

References clFact, counter, fClusJets, fDJROutFlag, fDJROutput, fExcLocal, fJetFinder, fPtSortedJets, lhef::LHEEvent::getHEPEUP(), mps_fire::i, heavyIonCSV_trainingSettings::idx, LESS_JETS, muonTagProbeFilters_cff::matched, SiStripPI::max, MORE_JETS, NONE, funct::pow(), HLT_2023v12_cff::pt2, lhef::HEPEUP::PUP, qCut, qCutSq, mathSSE::sqrt(), typeIdx, and UNMATCHED_PARTON.

                                                                                                              {
    // Number of hard partons
    //
    int NPartons = typeIdx[0].size();

    fClusJets.clear();
    fPtSortedJets.clear();

    int ClusSeqNJets = 0;

    fastjet::ClusterSequence ClusSequence(*jetInput, *fJetFinder);

    if (fExcLocal) {
      fClusJets = ClusSequence.exclusive_jets(qCutSq);
    } else {
      fClusJets = ClusSequence.inclusive_jets(qCut);
    }

    ClusSeqNJets = fClusJets.size();

    if (ClusSeqNJets < NPartons)
      return LESS_JETS;

    double localQcutSq = qCutSq;

    if (fExcLocal)  // exclusive
    {
      if (ClusSeqNJets > NPartons)
        return MORE_JETS;
    } else  // inclusive
    {
      fPtSortedJets = fastjet::sorted_by_pt(*jetInput);
      localQcutSq = std::max(qCutSq, fPtSortedJets[0].pt2());
      fClusJets = ClusSequence.exclusive_jets(NPartons);  // override
      ClusSeqNJets = NPartons;
    }

    if (clFact != 0)
      localQcutSq *= pow(clFact, 2);

    std::vector<fastjet::PseudoJet> MatchingInput;

    std::vector<bool> jetAssigned;
    jetAssigned.assign(fClusJets.size(), false);

    int counter = 0;

    const lhef::HEPEUP &hepeup = *partonLevel->getHEPEUP();

    while (counter < NPartons) {
      MatchingInput.clear();

      for (int i = 0; i < ClusSeqNJets; i++) {
        if (jetAssigned[i])
          continue;
        if (i == NPartons)
          break;
        //
        // this looks "awkward" but this way we do NOT pass in cluster_hist_index
        // which would actually indicate position in "history" of the "master" ClusSeq
        //
        fastjet::PseudoJet exjet = fClusJets[i];
        MatchingInput.push_back(fastjet::PseudoJet(exjet.px(), exjet.py(), exjet.pz(), exjet.e()));
        MatchingInput.back().set_user_index(i);
      }

      int idx = typeIdx[0][counter];
      MatchingInput.push_back(
          fastjet::PseudoJet(hepeup.PUP[idx][0], hepeup.PUP[idx][1], hepeup.PUP[idx][2], hepeup.PUP[idx][3]));

      //
      // in principle, one can use ClusterSequence::n_particles()
      //
      int NBefore = MatchingInput.size();

      // Create new clustering object - which includes the 1st clustering run !!!
      // NOTE-1: it better be a new object for each try, or history will be "too crowded".
      // NOTE-2: when created, the it ALWAYS makes at least 1 clustering step, so in most
      //         cases at least 1 new jet object will be added; although in some cases
      //         no jet is added, if the system doesn't cluster to anything (for example,
      //         input jet(s) and parton(s) are going opposite directions)
      //
      fastjet::ClusterSequence ClusSeq(MatchingInput, *fJetFinder);

      const std::vector<fastjet::PseudoJet> &output = ClusSeq.jets();
      int NClusJets = output.size() - NBefore;

      //
      // JVY - I think this is the right idea:
      // at least 1 (one) new jet needs to be added
      // however, need to double check details and refine, especially for inclusive mode
      //
      //
      if (NClusJets < 1) {
        return UNMATCHED_PARTON;
      }
      //
      // very unlikely case but let's do it just to be safe
      //
      if (NClusJets >= NBefore) {
        return MORE_JETS;
      }

      // Now browse history and see how close the clustering distance
      //
      // NOTE: Remember, there maybe more than one new jet in the list (for example,
      //       for process=2,3,...);
      //       in this case we take the ** first ** one that satisfies the distance/cut,
      //       which is ** typically ** also the best one
      //
      bool matched = false;
      const std::vector<fastjet::ClusterSequence::history_element> &history = ClusSeq.history();

      // for ( unsigned int i=nBefore; i<history.size(); i++ )
      for (unsigned int i = NBefore; i < output.size(); i++) {
        int hidx = output[i].cluster_sequence_history_index();
        double dNext = history[hidx].dij;
        if (dNext < localQcutSq) {
          //
          // the way we form input, parent1 is always jet, and parent2 can be any,
          // but if it's a good match/cluster, it should point at the parton
          //
          int parent1 = history[hidx].parent1;
          int parent2 = history[hidx].parent2;
          if (parent1 < 0 || parent2 < 0)
            break;  // bad cluster, no match
          //
          // pull up jet's "global" index
          //
          int pidx = MatchingInput[parent1].user_index();
          jetAssigned[pidx] = true;
          matched = true;
          break;
        }
      }
      if (!matched) {
        return UNMATCHED_PARTON;
      }

      counter++;
    }

    // Now save some info for DJR analysis (if requested).
    // This mimics what is done in ME2pythia.f
    // Basically, NJets and matching scale for these 4 cases:
    // 1->0, 2->1, 3->2, and 4->3
    //
    if (fDJROutFlag > 0) {
      std::vector<double> MergingScale;
      MergingScale.clear();
      for (int nj = 0; nj < 4; nj++) {
        double dmscale2 = ClusSequence.exclusive_dmerge(nj);
        double dmscale = sqrt(dmscale2);
        MergingScale.push_back(dmscale);
      }
      fDJROutput.open("events.tree", std::ios_base::app);
      double dNJets = (double)NPartons;
      fDJROutput << " " << dNJets << " " << MergingScale[0] << " " << MergingScale[1] << " " << MergingScale[2] << " "
                 << MergingScale[3] << std::endl;
      fDJROutput.close();
    }

    return NONE;
  }

parseParameter() [1/3]

template<>

std::string gen::JetMatchingMGFastJet::parseParameter

(

const std::string &

value

)

Definition at line 55 of file JetMatchingMGFastJet.cc.

References mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                       {
    std::string result;
    if (!result.empty() && result[0] == '\'')
      result = result.substr(1);
    if (!result.empty() && result[result.length() - 1] == '\'')
      result.resize(result.length() - 1);
    return result;
  }

parseParameter() [2/3]

template<typename T >

T gen::JetMatchingMGFastJet::parseParameter ( const std::string &  value )

staticprivate

Definition at line 47 of file JetMatchingMGFastJet.cc.

References mps_fire::result, and contentValuesCheck::ss.

                                                               {
    std::istringstream ss(value);
    T result;
    ss >> result;
    return result;
  }

parseParameter() [3/3]

template<>

bool gen::JetMatchingMGFastJet::parseParameter

(

const std::string &

value_

)

Definition at line 65 of file JetMatchingMGFastJet.cc.

References createfilelist::int, AlCaHLTBitMon_QueryRunRegistry::string, HcalDetIdTransform::transform(), and relativeConstraints::value.

                                                                   {
    std::string value(value_);
    std::transform(value.begin(), value.end(), value.begin(), (int (*)(int))std::toupper);
    return value == "T" || value == "Y" || value == "True" || value == "1" || value == ".TRUE.";
  }

updateOrDie()

template<typename T >

void gen::JetMatchingMGFastJet::updateOrDie ( const std::map< std::string, std::string > &  params, T &  param, const std::string &  name  )

staticprivate

Definition at line 112 of file JetMatchingMGFastJet.cc.

References Exception, getParameter(), Skims_PA_cff::name, and submitPVValidationJobs::params.

Referenced by init().

                                                                {
    if (param < 0) {
      param = getParameter(params, name, param);
    }
    if (param < 0)
      throw cms::Exception("Generator|PartonShowerVeto") << "The MGParamCMS header does not specify the jet "
                                                            "matching parameter \""
                                                         << name
                                                         << "\", but it "
                                                            "is requested by the CMSSW configuration."
                                                         << std::endl;
  }

Member Data Documentation

clFact

double gen::JetMatchingMGFastJet::clFact

private

Definition at line 76 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

coneRadius

double gen::JetMatchingMGFastJet::coneRadius

private

Definition at line 87 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

doMerge

bool gen::JetMatchingMGFastJet::doMerge

private

Definition at line 80 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

etaJetMax

double gen::JetMatchingMGFastJet::etaJetMax

private

Definition at line 87 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

exclusive

bool gen::JetMatchingMGFastJet::exclusive

private

Definition at line 99 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and JetMatchingMGFastJet().

fClusJets

std::vector<fastjet::PseudoJet> gen::JetMatchingMGFastJet::fClusJets

private

Definition at line 105 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

fDJROutFlag

int gen::JetMatchingMGFastJet::fDJROutFlag

private

Definition at line 110 of file JetMatchingMGFastJet.h.

Referenced by JetMatchingMGFastJet(), and match().

fDJROutput

std::ofstream gen::JetMatchingMGFastJet::fDJROutput

private

Definition at line 109 of file JetMatchingMGFastJet.h.

Referenced by match().

fExcLocal

bool gen::JetMatchingMGFastJet::fExcLocal

private

Definition at line 92 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), initAfterBeams(), and match().

fIsInit

bool gen::JetMatchingMGFastJet::fIsInit

private

Definition at line 112 of file JetMatchingMGFastJet.h.

Referenced by init(), and initAfterBeams().

fJetFinder

fastjet::JetDefinition* gen::JetMatchingMGFastJet::fJetFinder

private

Definition at line 104 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), match(), and ~JetMatchingMGFastJet().

fPtSortedJets

std::vector<fastjet::PseudoJet> gen::JetMatchingMGFastJet::fPtSortedJets

private

Definition at line 105 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

jetAlgoPower

int gen::JetMatchingMGFastJet::jetAlgoPower

private

Definition at line 86 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

mgParams

std::map<std::string, std::string> gen::JetMatchingMGFastJet::mgParams

private

Definition at line 68 of file JetMatchingMGFastJet.h.

Referenced by getParameter(), and init().

nJetMax

int gen::JetMatchingMGFastJet::nJetMax

private

Definition at line 83 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and initAfterBeams().

nJetMin

int gen::JetMatchingMGFastJet::nJetMin

private

Definition at line 83 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

nQmatch

int gen::JetMatchingMGFastJet::nQmatch

private

Definition at line 77 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and initAfterBeams().

qCut

double gen::JetMatchingMGFastJet::qCut

private

Definition at line 75 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

qCutSq

double gen::JetMatchingMGFastJet::qCutSq

private

Definition at line 75 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

runInitialized

bool gen::JetMatchingMGFastJet::runInitialized

private

Definition at line 97 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and init().

soup

bool gen::JetMatchingMGFastJet::soup

private

Definition at line 98 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and JetMatchingMGFastJet().

typeIdx

std::vector<int> gen::JetMatchingMGFastJet::typeIdx[3]

private

Definition at line 95 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), getPartonList(), and match().