gen::JetMatchingMGFastJet Class Reference

#include <JetMatchingMGFastJet.h>

Inheritance diagram for gen::JetMatchingMGFastJet:

Public Member Functions
const std::vector< int > *	getPartonList ()
	JetMatchingMGFastJet (const edm::ParameterSet &params)
template<>
std::string	parseParameter (const std::string &value)
template<>
bool	parseParameter (const std::string &value_)
	~JetMatchingMGFastJet ()
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
virtual void	beforeHadronisation (const lhef::LHEEvent *)
virtual void	beforeHadronisationExec ()
virtual double	getJetEtaMax () const
virtual void	init (const lhef::LHERunInfo *runInfo)
virtual bool	initAfterBeams ()
virtual int	match (const lhef::LHEEvent *partonLevel, const std::vector< fastjet::PseudoJet > *jetInput)

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::auto_ptr< JetMatching >	create (const edm::ParameterSet &params)
Protected Attributes inherited from gen::JetMatching
bool	fMatchingStatus

Detailed Description

Definition at line 32 of file JetMatchingMGFastJet.h.

Member Enumeration Documentation

enum gen::JetMatchingMGFastJet::partonTypes

private

Enumerator
ID_TOP
ID_GLUON
ID_PHOTON

Definition at line 77 of file JetMatchingMGFastJet.h.

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

enum gen::JetMatchingMGFastJet::vetoStatus

private

Enumerator
NONE
LESS_JETS
MORE_JETS
HARD_JET
UNMATCHED_PARTON

Definition at line 76 of file JetMatchingMGFastJet.h.

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

Constructor & Destructor Documentation

gen::JetMatchingMGFastJet::JetMatchingMGFastJet

(

const edm::ParameterSet &

params

)

Definition at line 153 of file JetMatchingMGFastJet.cc.

References gen::MEMAIN::clfact, gen::MEMAIN::etaclmax, gen::MEMAIN::etcjet, Exception, exclusive, gen::MEMAIN::excres, fDJROutFlag, gen::OUTTREE::flag, edm::ParameterSet::getParameter(), diffTreeTool::index, gen::MEMAIN::ktsche, gen::MEMAIN::maxjets, gen::memain_, gen::MEMAIN::minjets, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, gen::MEMAIN::nexcres, gen::MEMAIN::nqmatch, gen::outtree_, gen::MEMAIN::qcut, gen::MEMAIN::rclmax, gen::MEMAIN::showerkt, soup, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                        :
        JetMatching(params),
        runInitialized(false),
        fJetFinder(0),
        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"); 
}

gen::JetMatchingMGFastJet::~JetMatchingMGFastJet ( )

inline

Definition at line 39 of file JetMatchingMGFastJet.h.

References fJetFinder.

{ if (fJetFinder) delete fJetFinder; }

Member Function Documentation

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

protectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 251 of file JetMatchingMGFastJet.cc.

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

Referenced by getPartonList().

{

   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;

}

virtual void gen::JetMatchingMGFastJet::beforeHadronisationExec ( )

inlineprotectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 49 of file JetMatchingMGFastJet.h.

References getJetEtaMax(), getParameter(), match(), dataset::name, parseParameter(), AlCaHLTBitMon_QueryRunRegistry::string, updateOrDie(), and JetChargeProducer_cfi::var.

{ return; }

double gen::JetMatchingMGFastJet::getJetEtaMax ( ) const

protectedvirtual

Implements gen::JetMatching.

Definition at line 201 of file JetMatchingMGFastJet.cc.

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

Referenced by beforeHadronisationExec().

{
  return memain_.etaclmax;
}

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 87 of file JetMatchingMGFastJet.cc.

Referenced by beforeHadronisationExec().

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

template<typename T >

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

private

Definition at line 99 of file JetMatchingMGFastJet.cc.

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

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

inlinevirtual

Reimplemented from gen::JetMatching.

Definition at line 41 of file JetMatchingMGFastJet.h.

References beforeHadronisation(), init(), initAfterBeams(), and typeIdx.

{ return typeIdx; }

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

protectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 304 of file JetMatchingMGFastJet.cc.

References gather_cfg::cout, gen::MEMAIN::etaclmax, lhef::LHERunInfo::findHeader(), fIsInit, RecoTauValidation_cfi::header, gen::UPPRIV::ickkw, initAfterBeams(), gen::MEMAIN::maxjets, gen::MEMAIN::mektsc, gen::memain_, mgParams, gen::MEMAIN::minjets, gen::MEMAIN::nqmatch, metProducer_cfi::parameters, gen::parseHeader(), gen::MEMAIN::qcut, runInitialized, gen::MEMAIN::showerkt, updateOrDie(), gen::uppriv_, and MuonErrorMatrixValues_cff::values.

Referenced by getPartonList().

{
        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;
}

bool gen::JetMatchingMGFastJet::initAfterBeams ( )

protectedvirtual

Reimplemented from gen::JetMatching.

Definition at line 207 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 getPartonList(), and 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;

}

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

protectedvirtual

Implements gen::JetMatching.

Definition at line 364 of file JetMatchingMGFastJet.cc.

References clFact, counter, funct::false, fClusJets, fDJROutFlag, fDJROutput, fExcLocal, fJetFinder, fPtSortedJets, lhef::LHEEvent::getHEPEUP(), mps_fire::i, training_settings::idx, LESS_JETS, electronMatch_cfi::matched, hpstanc_transforms::max, MORE_JETS, NONE, convertSQLitetoXML_cfg::output, funct::pow(), hiDetachedQuadStep_cff::pt2, lhef::HEPEUP::PUP, qCut, qCutSq, mathSSE::sqrt(), typeIdx, and UNMATCHED_PARTON.

Referenced by beforeHadronisationExec().

{
         
   // 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;

}

template<typename T >

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

staticprivate

Definition at line 56 of file JetMatchingMGFastJet.cc.

References mps_fire::result.

Referenced by beforeHadronisationExec().

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

template<>

std::string gen::JetMatchingMGFastJet::parseParameter

(

const std::string &

value

)

Definition at line 65 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;
}

template<>

bool gen::JetMatchingMGFastJet::parseParameter

(

const std::string &

value_

)

Definition at line 76 of file JetMatchingMGFastJet.cc.

References createfilelist::int, AlCaHLTBitMon_QueryRunRegistry::string, create_public_lumi_plots::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.";
}

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 137 of file JetMatchingMGFastJet.cc.

References Exception.

Referenced by beforeHadronisationExec(), and 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

double gen::JetMatchingMGFastJet::clFact

private

Definition at line 80 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

double gen::JetMatchingMGFastJet::coneRadius

private

Definition at line 91 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

bool gen::JetMatchingMGFastJet::doMerge

private

Definition at line 84 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

double gen::JetMatchingMGFastJet::etaJetMax

private

Definition at line 91 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

bool gen::JetMatchingMGFastJet::exclusive

private

Definition at line 103 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and JetMatchingMGFastJet().

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

private

Definition at line 109 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

int gen::JetMatchingMGFastJet::fDJROutFlag

private

Definition at line 114 of file JetMatchingMGFastJet.h.

Referenced by JetMatchingMGFastJet(), and match().

std::ofstream gen::JetMatchingMGFastJet::fDJROutput

private

Definition at line 113 of file JetMatchingMGFastJet.h.

Referenced by match().

bool gen::JetMatchingMGFastJet::fExcLocal

private

Definition at line 96 of file JetMatchingMGFastJet.h.

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

bool gen::JetMatchingMGFastJet::fIsInit

private

Definition at line 116 of file JetMatchingMGFastJet.h.

Referenced by init(), and initAfterBeams().

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

private

Definition at line 108 of file JetMatchingMGFastJet.h.

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

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

private

Definition at line 109 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

int gen::JetMatchingMGFastJet::jetAlgoPower

private

Definition at line 90 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

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

private

Definition at line 72 of file JetMatchingMGFastJet.h.

Referenced by init().

int gen::JetMatchingMGFastJet::nJetMax

private

Definition at line 87 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and initAfterBeams().

int gen::JetMatchingMGFastJet::nJetMin

private

Definition at line 87 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams().

int gen::JetMatchingMGFastJet::nQmatch

private

Definition at line 81 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and initAfterBeams().

double gen::JetMatchingMGFastJet::qCut

private

Definition at line 79 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

double gen::JetMatchingMGFastJet::qCutSq

private

Definition at line 79 of file JetMatchingMGFastJet.h.

Referenced by initAfterBeams(), and match().

bool gen::JetMatchingMGFastJet::runInitialized

private

Definition at line 101 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and init().

bool gen::JetMatchingMGFastJet::soup

private

Definition at line 102 of file JetMatchingMGFastJet.h.

Referenced by beforeHadronisation(), and JetMatchingMGFastJet().

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

private

Definition at line 99 of file JetMatchingMGFastJet.h.

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