Pythia8::PowhegV_EW Class Reference

Inheritance diagram for Pythia8::PowhegV_EW:

Collaboration diagram for Pythia8::PowhegV_EW:

Public Member Functions
	PowhegV_EW ()
	~PowhegV_EW ()
bool	initAfterBeams ()
double	pTpythia (const Event &e, int RadAfterBranch, int EmtAfterBranch, int RecAfterBranch, bool FSR)
double	pTpowheg (const Event &e, int i, int j, bool FSR)
double	pTcalc (const Event &e, int i, int j, int k, int r, int xSRin)
bool	canVetoMPIStep ()
int	numberVetoMPIStep ()
bool	doVetoMPIStep (int nMPI, const Event &e)
bool	canVetoISREmission ()
bool	doVetoISREmission (int, const Event &e, int iSys)
bool	canVetoFSREmission ()
bool	doVetoFSREmission (int, const Event &e, int iSys, bool inr)
bool	canVetoMPIEmission ()
bool	doVetoMPIEmission (int, const Event &e)
int	getNISRveto ()
int	getNFSRveto ()

Private Attributes
int	m_nFinal {}
int	m_vetoMode {}
int	m_vetoCount {}
int	m_pThardMode {}
int	m_pTemtMode {}
int	m_emittedMode {}
int	m_pTdefMode {}
int	m_MPIvetoMode {}
double	m_pThard {}
double	m_pTMPI {}
bool	m_accepted {}
int	m_nAcceptSeq {}
unsigned long int	m_nISRveto {}
unsigned long int	m_nFSRveto {}
si_data_type	m_si_data_ {}
si_event_info_type	m_si_event_info_ {}

Detailed Description

Definition at line 118 of file PowhegV_EW.cxx.

Constructor & Destructor Documentation

PowhegV_EW()

Pythia8::PowhegV_EW::PowhegV_EW ( )

inline

Definition at line 123 of file PowhegV_EW.cxx.

                 {
 
      std::cout<<"**********************************************************"<<std::endl;
      std::cout<<"*                                                        *"<<std::endl;
      std::cout<<"*     SI: Defining modified PowhegHook to perform        *"<<std::endl;
      std::cout<<"*          the matching  (ptmaxmatch = 2)                *"<<std::endl;
      std::cout<<"*                                                        *"<<std::endl;
      std::cout<<"**********************************************************"<<std::endl;
 
      Pythia8_UserHooks::UserHooksFactory::userSettings<bool>()["m_si_data_.vetoqed"]=true;
      Pythia8_UserHooks::UserHooksFactory::userSettings<bool>()["m_si_data_.py8veto"]=true;
      Pythia8_UserHooks::UserHooksFactory::userSettings<double>()["m_si_event_info_.vetoscale_fsr"]=10.0;
      Pythia8_UserHooks::UserHooksFactory::userSettings<double>()["m_si_event_info_.vetoscale_isr"]=10.0;
 
    };

~PowhegV_EW()

Pythia8::PowhegV_EW::~PowhegV_EW ( )

inline

Definition at line 139 of file PowhegV_EW.cxx.

{}

Member Function Documentation

canVetoFSREmission()

bool Pythia8::PowhegV_EW::canVetoFSREmission ( )

inline

Definition at line 538 of file PowhegV_EW.cxx.

{ return (m_vetoMode == 0) ? false : true; }

canVetoISREmission()

bool Pythia8::PowhegV_EW::canVetoISREmission ( )

inline

Definition at line 482 of file PowhegV_EW.cxx.

{ return (m_vetoMode == 0) ? false : true; }

canVetoMPIEmission()

bool Pythia8::PowhegV_EW::canVetoMPIEmission ( )

inline

Definition at line 642 of file PowhegV_EW.cxx.

{ return (m_MPIvetoMode == 0) ? false : true; }

canVetoMPIStep()

bool Pythia8::PowhegV_EW::canVetoMPIStep ( )

inline

Definition at line 406 of file PowhegV_EW.cxx.

{ return true; }

doVetoFSREmission()

bool Pythia8::PowhegV_EW::doVetoFSREmission ( int , const Event & e, int iSys, bool inr )

inline

Definition at line 539 of file PowhegV_EW.cxx.

                                                                    {
      // radiation from the hard system: isys=0
      // radiation from resonances: isys!=0 and inr=1
      // MPI radiation: isys!=0 and inr=0
 
      // we do not veto MPI radiation
      // if we veto here gamma from resonance (inr==1), 
      // we do not have to use canSetResonanceScale 
      if (iSys != 0 && inr != 1) return false;
 
      // In case of radiation from resonance we veto
      // This is used for ptmaxmatch = 2. 
      // If py8veto = 1, this method is also used to veto photons, otherwise, use external function
      // force the radiation scale, m_pThard, to be equal to the one set in the LHE file
      if (inr == 1) {
    if ((m_si_data_.vetoqed == false) || (m_si_data_.py8veto == false)) {
      return false;
    }
    else {
      // Set scale for FSR from the resonance
      m_pThard = m_si_event_info_.vetoscale_fsr;
    }
      }
      
 
      // If m_vetocount != 0 and we already have accepted 'vetoCount' emissions in a row,
      // do nothing; if m_vetocount = 0 check all emissions
      if (m_vetoCount != 0 && m_nAcceptSeq >= m_vetoCount) return false;
 
      // Pythia radiator (before and after), emitted and recoiler (after)
      int iRecAft = e.size() - 1;
      int iEmt    = e.size() - 2;
      int iRadAft = e.size() - 3;
      int iRadBef = e[iEmt].mother1();
      if ( (e[iRecAft].status() != 52 && e[iRecAft].status() != -53) ||
       e[iEmt].status() != 51 || e[iRadAft].status() != 51) {
    e.list();
    std::cout << "Error: couldn't find Pythia FSR emission" << std::endl;
    exit(1);
      }
 
      // Behaviour based on m_pTemtMode:
      //  0 - pT of emitted w.r.t. radiator before
      //  1 - min(pT of emitted w.r.t. all incoming/outgoing)
      //  2 - min(pT of all outgoing w.r.t. all incoming/outgoing)
      int xSR = (m_pTemtMode == 0) ? 1       : -1;
 
      int i   = (m_pTemtMode == 0) ? iRadBef : -1;
      i = (m_pTdefMode == 1) ? iRadAft : iRadBef;
      // using POWHEG pT definition i should be iRadAft (daugther)
      int k   = (m_pTemtMode == 0) ? iRadAft : -1;
      int r   = (m_pTemtMode == 0) ? iRecAft : -1;
 
      // When pTemtMode is 0 or 1, iEmt has been selected
      double pTemt = 0.;
      if (m_pTemtMode == 0 || m_pTemtMode == 1) {
    // Which parton is emitted, based on m_emittedMode:
    //  0 - Pythia definition of emitted
    //  1 - Pythia definition of radiated after emission
    //  2 - Random selection of emitted or radiated after emission
    //  3 - Try both emitted and radiated after emission
 
    // j = radiator after
 
    int j = iRadAft;
    //m_emittedMode = 0 -> j = iRadAft + 1 = iEmt 
    if (m_emittedMode == 0 || (m_emittedMode == 2 && rndmPtr->flat() < 0.5)) j++;
 
    for (int jLoop = 0; jLoop < 2; jLoop++) {
      if      (jLoop == 0) pTemt = pTcalc(e, i, j, k, r, xSR);
      else if (jLoop == 1) pTemt = min(pTemt, pTcalc(e, i, j, k, r, xSR));
  
      // For m_emittedMode == 3, have tried iRadAft, now try iEmt
      if (m_emittedMode != 3) break;
      if (k != -1) swap(j, k); else j = iEmt;
    }
 
    // If m_pTemtMode is 2, then try all final-state partons as emitted
      } else if (m_pTemtMode == 2) {
    pTemt = pTcalc(e, i, -1, k, r, xSR);
      }
 
#ifdef DBGOUTPUT
      std::cout << "doVetoFSREmission: pTemt = " << pTemt << std::endl;
#endif
 
      // Veto if pTemt > m_pThard
      if (pTemt > m_pThard) {
    m_nAcceptSeq = 0;
    m_nFSRveto++;
    return true;
      }
 
      // Else mark that an emission has been accepted and continue
      m_nAcceptSeq++;
      m_accepted = true;
      return false;
    }

doVetoISREmission()

bool Pythia8::PowhegV_EW::doVetoISREmission ( int , const Event & e, int iSys )

inline

Definition at line 483 of file PowhegV_EW.cxx.

                                                          {
 
      // Must be radiation from the hard system, otherwise return
      if (iSys != 0) return false;
 
      // If m_vetocount != 0 and we already have accepted 'vetoCount' emissions in a row,
      // do nothing; if m_vetocount = 0 check all emissions
      if (m_vetoCount != 0 && m_nAcceptSeq >= m_vetoCount) return false;
 
      // Pythia radiator after, emitted and recoiler after.
      int iRadAft = -1, iEmt = -1, iRecAft = -1;
      for (int i = e.size() - 1; i > 0; i--) {
    if      (iRadAft == -1 && e[i].status() == -41) iRadAft = i;
    else if (iEmt    == -1 && e[i].status() ==  43) iEmt    = i;
    else if (iRecAft == -1 && e[i].status() == -42) iRecAft = i;
    if (iRadAft != -1 && iEmt != -1 && iRecAft != -1) break;
      }
      if (iRadAft == -1 || iEmt == -1 || iRecAft == -1) {
    e.list();
    std::cout << "Error: couldn't find Pythia ISR emission" << std::endl;
    exit(1);
      }
 
      // m_pTemtMode == 0: pT of emitted w.r.t. radiator
      // m_pTemtMode == 1: min(pT of emitted w.r.t. all incoming/outgoing)
      // m_pTemtMode == 2: min(pT of all outgoing w.r.t. all incoming/outgoing)
      int xSR      = (m_pTemtMode == 0) ? 0       : -1;
      int i        = (m_pTemtMode == 0) ? iRadAft : -1;
      int j        = (m_pTemtMode != 2) ? iEmt    : -1;
      int k        = -1;
      int r        = (m_pTemtMode == 0) ? iRecAft : -1;
      double pTemt = pTcalc(e, i, j, k, r, xSR);
 
#ifdef DBGOUTPUT
      std::cout << "doVetoISREmission: pTemt = " << pTemt << std::endl;
#endif
 
      // Veto if pTemt > m_pThard
      if (pTemt > m_pThard) {
    m_nAcceptSeq = 0;
    m_nISRveto++;
    return true;
      }
 
      // Else mark that an emission has been accepted and continue
      m_nAcceptSeq++;
      m_accepted = true;
 
      return false;
    }

doVetoMPIEmission()

bool Pythia8::PowhegV_EW::doVetoMPIEmission ( int , const Event & e )

inline

Definition at line 643 of file PowhegV_EW.cxx.

                                                {
 
      if (m_MPIvetoMode == 1) {
    if (e[e.size() - 1].pT() > m_pTMPI) {
#ifdef DBGOUTPUT
      std::cout << "doVetoMPIEmission: pTnow = " << e[e.size() - 1].pT()
           << ", pTMPI = " << m_pTMPI << std::endl;
#endif
      return true;
    }
      }
      return false;
    }

doVetoMPIStep()

bool Pythia8::PowhegV_EW::doVetoMPIStep ( int nMPI, const Event & e )

inline

Definition at line 408 of file PowhegV_EW.cxx.

                                                 {
 
      if (nMPI > 1) return false;
 
      // Find if there is a POWHEG emission. Go backwards through the
      // event record until there is a non-final particle. Also sum pT and
      // find pT_1 for possible MPI vetoing
      int    count = 0;
      double pT1 = 0., pTsum = 0.;
      for (int i = e.size() - 1; i > 0; i--) {
    if (e[i].isFinal()) {
      count++;
      pT1    = e[i].pT();
      pTsum += e[i].pT();
    } else break;
      }
      // Extra check that we have the correct final state
      if (count != m_nFinal && count != m_nFinal + 1) {
    std::cout << "Error: wrong number of final state particles in event" << std::endl;
    exit(1);
      }
      // Flag if POWHEG radiation present and index
      bool isEmt = (count == m_nFinal) ? false : true;
      int  iEmt  = (isEmt) ? e.size() - 1 : -1;
 
      // If there is no radiation or if m_pThardMode is 0 then set m_pThard = SCALUP.
      m_pThard = -1;
      // m_pThardMode is 0
      if (!isEmt || m_pThardMode == 0) {
    // This sets the scale to veto emissions in the QCD shower by Pythia
    // This scale is used for all emissions, except if they come from the resonance
    m_pThard = m_si_event_info_.vetoscale_isr;
    // Not using directly scalup, because the special file LHE (two scales)
      
    // If m_pThardMode is 1 then the pT of the POWHEG emission is checked against
    // all other incoming and outgoing partons, with the minimal value taken
      } else if (m_pThardMode == 1) {
    m_pThard = pTcalc(e, -1, iEmt, -1, -1, -1);
 
    // If m_pThardMode is 2, then the pT of all final-state partons is checked
    // against all other incoming and outgoing partons, with the minimal value
    // taken
      } else if (m_pThardMode == 2) {
    m_pThard = pTcalc(e, -1, -1, -1, -1, -1);
      }
 
      // Find MPI veto pT if necessary
      if (m_MPIvetoMode == 1) {
    m_pTMPI = (isEmt) ? pTsum / 2. : pT1;
      }
 
#ifdef DBGOUTPUT
      std::cout << "doVetoMPIStep: Qfac = " << infoPtr->scalup()
       << ", pThard = " << m_pThard << std::endl;
#endif
 
      // Initialise other variables
      m_accepted   = false;
      m_nAcceptSeq = m_nISRveto = m_nFSRveto = 0;
 
      if(m_pThard < 0)
    {
      std::cout << "something wrong with pThard = " << m_pThard << std::endl;
      exit(1);
    }
 
      // Do not veto the event
      return false;
    }

getNFSRveto()

int Pythia8::PowhegV_EW::getNFSRveto ( )

inline

Definition at line 662 of file PowhegV_EW.cxx.

{ return m_nFSRveto; }

getNISRveto()

int Pythia8::PowhegV_EW::getNISRveto ( )

inline

Definition at line 661 of file PowhegV_EW.cxx.

{ return m_nISRveto; }

initAfterBeams()

bool Pythia8::PowhegV_EW::initAfterBeams ( )

inline

Definition at line 142 of file PowhegV_EW.cxx.

                          {
      m_nFinal      = settingsPtr->mode("POWHEG:nFinal");
      m_vetoMode    = settingsPtr->mode("POWHEG:veto");
      m_vetoCount   = settingsPtr->mode("POWHEG:vetoCount");
      m_pThardMode  = settingsPtr->mode("POWHEG:pThard");
      m_pTemtMode   = settingsPtr->mode("POWHEG:pTemt");
      m_emittedMode = settingsPtr->mode("POWHEG:emitted");
      m_pTdefMode   = settingsPtr->mode("POWHEG:pTdef");
      m_MPIvetoMode = settingsPtr->mode("POWHEG:MPIveto");
 
      m_si_data_.vetoqed              = settingsPtr->mode("si_data_.vetoqed");
      m_si_data_.py8veto              = settingsPtr->mode("si_data_.py8veto");
      m_si_event_info_.vetoscale_fsr  = settingsPtr->mode("m_si_event_info_.vetoscale_fsr");
      m_si_event_info_.vetoscale_isr  = settingsPtr->mode("m_si_event_info_.vetoscale_isr");
      return true;
    }

numberVetoMPIStep()

int Pythia8::PowhegV_EW::numberVetoMPIStep ( )

inline

Definition at line 407 of file PowhegV_EW.cxx.

{ return 1; }

pTcalc()

double Pythia8::PowhegV_EW::pTcalc ( const Event & e, int i, int j, int k, int r, int xSRin )

inline

Definition at line 276 of file PowhegV_EW.cxx.

                                                                         {
 
 
      // Loop over ISR and FSR if necessary
      double pTemt = -1., pTnow;
      int xSR1 = (xSRin == -1) ? 0 : xSRin;
      int xSR2 = (xSRin == -1) ? 2 : xSRin + 1;
      for (int xSR = xSR1; xSR < xSR2; xSR++) {
    // FSR flag
    bool FSR = (xSR == 0) ? false : true;
 
    // If all necessary arguments have been given, then directly calculate.
    // POWHEG ISR and FSR, need i and j.
    if ((m_pTdefMode == 0 || m_pTdefMode == 1) && i > 0 && j > 0) {
      pTemt = pTpowheg(e, i, j, (m_pTdefMode == 0) ? false : FSR);
 
      // Pythia ISR, need i, j and r.
    } else if (!FSR && m_pTdefMode == 2 && i > 0 && j > 0 && r > 0) {
      pTemt = pTpythia(e, i, j, r, FSR);
 
      // Pythia FSR, need k, j and r.
    } else if (FSR && m_pTdefMode == 2 && j > 0 && k > 0 && r > 0) {
      pTemt = pTpythia(e, k, j, r, FSR);
 
      // Otherwise need to try all possible combintations.
    } else {
      // Start by finding incoming legs to the hard system after
      // branching (radiator after branching, i for ISR).
      // Use partonSystemsPtr to find incoming just prior to the
      // branching and track mothers.
      int iInA = partonSystemsPtr->getInA(0);
      int iInB = partonSystemsPtr->getInB(0);
      while (e[iInA].mother1() != 1) { iInA = e[iInA].mother1(); }
      while (e[iInB].mother1() != 2) { iInB = e[iInB].mother1(); }
 
      // If we do not have j, then try all final-state partons
      int jNow = (j > 0) ? j : 0;
      int jMax = (j > 0) ? j + 1 : e.size();
      for (; jNow < jMax; jNow++) {
 
        // Final-state jNow only
        if ( !e[jNow].isFinal() ) continue;
 
        // POWHEG
        if (m_pTdefMode == 0 || m_pTdefMode == 1) {
 
          // ISR - only done once as just kinematical pT
          if (!FSR) {
        pTnow = pTpowheg(e, iInA, jNow, (m_pTdefMode == 0) ? false : FSR);
        if (pTnow > 0.) pTemt = (pTemt < 0) ? pTnow : min(pTemt, pTnow);
  
        // FSR - try all outgoing partons from system before branching 
        // as i. Note that for the hard system, there is no 
        // "before branching" information.
              } else {
 
                int outSize = partonSystemsPtr->sizeOut(0);
                for (int iMem = 0; iMem < outSize; iMem++) {
                  int iNow = partonSystemsPtr->getOut(0, iMem);
 
                  // Coloured only, i != jNow and no carbon copies
                  if (iNow == jNow) continue;
                  if (jNow == e[iNow].daughter1() 
              && jNow == e[iNow].daughter2()) continue;
 
                  pTnow = pTpowheg(e, iNow, jNow, (m_pTdefMode == 0) 
                   ? false : FSR);
                  if (pTnow > 0.) pTemt = (pTemt < 0) 
                    ? pTnow : min(pTemt, pTnow);
                } // for (iMem)
 
              } // if (!FSR)
  
          // Pythia
        } else if (m_pTdefMode == 2) {
  
          // ISR - other incoming as recoiler
          if (!FSR) {
        pTnow = pTpythia(e, iInA, jNow, iInB, FSR);
        if (pTnow > 0.) pTemt = (pTemt < 0) ? pTnow : min(pTemt, pTnow);
        pTnow = pTpythia(e, iInB, jNow, iInA, FSR);
        if (pTnow > 0.) pTemt = (pTemt < 0) ? pTnow : min(pTemt, pTnow);
  
        // FSR - try all final-state coloured partons as radiator
        //       after emission (k).
          } else {
        for (int kNow = 0; kNow < e.size(); kNow++) {
          if (kNow == jNow || !e[kNow].isFinal()) continue;
  
          // For this kNow, need to have a recoiler.
          // Try two incoming.
          pTnow = pTpythia(e, kNow, jNow, iInA, FSR);
          if (pTnow > 0.) pTemt = (pTemt < 0) 
                    ? pTnow : min(pTemt, pTnow);
          pTnow = pTpythia(e, kNow, jNow, iInB, FSR);
          if (pTnow > 0.) pTemt = (pTemt < 0) 
                    ? pTnow : min(pTemt, pTnow);
 
          // Try all other outgoing.
          for (int rNow = 0; rNow < e.size(); rNow++) {
            if (rNow == kNow || rNow == jNow ||
            !e[rNow].isFinal()) continue;
            pTnow = pTpythia(e, kNow, jNow, rNow, FSR);
            if (pTnow > 0.) pTemt = (pTemt < 0) 
                      ? pTnow : min(pTemt, pTnow);
          } // for (rNow)
  
        } // for (kNow)
          } // if (!FSR)
        } // if (m_pTdefMode)
      } // for (j)
    }
      } // for (xSR)
 
#ifdef DBGOUTPUT
      std::cout << "pTcalc: i = " << i << ", j = " << j << ", k = " << k
       << ", r = " << r << ", xSR = " << xSRin
       << ", pTemt = " << pTemt << std::endl;
#endif
 
      return pTemt;
    }

pTpowheg()

double Pythia8::PowhegV_EW::pTpowheg ( const Event & e, int i, int j, bool FSR )

inline

Definition at line 227 of file PowhegV_EW.cxx.

                                                            {
 
      // pT value for FSR and ISR
      double pTnow = 0.;
      if (FSR) {
    // POWHEG d_ij (in CM frame). Note that the incoming beams have not
    // been updated in the parton systems pointer yet (i.e. prior to any
    // potential recoil).
    int iInA = partonSystemsPtr->getInA(0);
    int iInB = partonSystemsPtr->getInB(0);
    double betaZ = - ( e[iInA].pz() + e[iInB].pz() ) /
      ( e[iInA].e() + e[iInB].e()  );
    Vec4 iVecBst(e[i].p()), jVecBst(e[j].p());
    iVecBst.bst(0., 0., betaZ);
    jVecBst.bst(0., 0., betaZ);
 
    if ( e[i].id() == 21 && e[j].id() == 21) {
          pTnow = std::sqrt( (iVecBst + jVecBst).m2Calc() *
                        iVecBst.e() * jVecBst.e() /
                        pow2(iVecBst.e() + jVecBst.e()) );
    } else {
          pTnow = std::sqrt( (iVecBst + jVecBst).m2Calc() *
                        jVecBst.e() / iVecBst.e() );
    }
 
      } else {
    // POWHEG pT_ISR is just kinematic pT
    pTnow = e[j].pT();
      }
 
      // Check result
      if (pTnow < 0.) {
    std::cout << "Warning: pTpowheg was negative" << std::endl;
    return -1.;
      }
 
#ifdef DBGOUTPUT
      std::cout << "pTpowheg: i = " << i << ", j = " << j
       << ", pTnow = " << pTnow << std::endl;
#endif
 
      return pTnow;
    }

pTpythia()

double Pythia8::PowhegV_EW::pTpythia ( const Event & e, int RadAfterBranch, int EmtAfterBranch, int RecAfterBranch, bool FSR )

inline

Definition at line 168 of file PowhegV_EW.cxx.

                                          {
 
      // Convenient shorthands for later
      Vec4 radVec = e[RadAfterBranch].p();
      Vec4 emtVec = e[EmtAfterBranch].p();
      Vec4 recVec = e[RecAfterBranch].p();
      int  radID  = e[RadAfterBranch].id();
 
      // Calculate virtuality of splitting
      double sign = (FSR) ? 1. : -1.;
      Vec4 Q(radVec + sign * emtVec); 
      double Qsq = sign * Q.m2Calc();
 
      // Mass term of radiator
      double m2Rad = (std::abs(radID) >= 4 && std::abs(radID) < 7) ?
    pow2(particleDataPtr->m0(radID)) : 0.;
 
      // z values for FSR and ISR
      double z, pTnow;
      if (FSR) {
    // Construct 2 -> 3 variables
    Vec4 sum = radVec + recVec + emtVec;
    double m2Dip = sum.m2Calc();
    double x1 = 2. * (sum * radVec) / m2Dip;
    double x3 = 2. * (sum * emtVec) / m2Dip;
    z     = x1 / (x1 + x3);
    pTnow = z * (1. - z);
 
      } else {
    // Construct dipoles before/after splitting
    Vec4 qBR(radVec - emtVec + recVec);
    Vec4 qAR(radVec + recVec);
    z     = qBR.m2Calc() / qAR.m2Calc();
    pTnow = (1. - z);
      }
 
      // Virtuality with correct sign
      pTnow *= (Qsq - sign * m2Rad);
 
      // Can get negative pT for massive splittings
      if (pTnow < 0.) {
    std::cout << "Warning: pTpythia was negative" << std::endl;
    return -1.;
      }
 
#ifdef DBGOUTPUT
      std::cout << "pTpythia: rad = " << RadAfterBranch << ", emt = "
       << EmtAfterBranch << ", rec = " << RecAfterBranch
       << ", pTnow = " << std::sqrt(pTnow) << std::endl;
#endif
 
      // Return pT
      return std::sqrt(pTnow);
    }

Member Data Documentation

m_accepted

bool Pythia8::PowhegV_EW::m_accepted {}

private

Definition at line 668 of file PowhegV_EW.cxx.

{};

m_emittedMode

int Pythia8::PowhegV_EW::m_emittedMode {}

private

Definition at line 666 of file PowhegV_EW.cxx.

{}, m_pTdefMode{}, m_MPIvetoMode{};

m_MPIvetoMode

int Pythia8::PowhegV_EW::m_MPIvetoMode {}

private

Definition at line 666 of file PowhegV_EW.cxx.

{}, m_pTdefMode{}, m_MPIvetoMode{};

m_nAcceptSeq

int Pythia8::PowhegV_EW::m_nAcceptSeq {}

private

Definition at line 670 of file PowhegV_EW.cxx.

{};

m_nFinal

int Pythia8::PowhegV_EW::m_nFinal {}

private

Definition at line 665 of file PowhegV_EW.cxx.

{}, m_vetoMode{}, m_vetoCount{}, m_pThardMode{}, m_pTemtMode{},

m_nFSRveto

unsigned long int Pythia8::PowhegV_EW::m_nFSRveto {}

private

Definition at line 672 of file PowhegV_EW.cxx.

{}, m_nFSRveto{};

m_nISRveto

unsigned long int Pythia8::PowhegV_EW::m_nISRveto {}

private

Definition at line 672 of file PowhegV_EW.cxx.

{}, m_nFSRveto{};

m_pTdefMode

int Pythia8::PowhegV_EW::m_pTdefMode {}

private

Definition at line 666 of file PowhegV_EW.cxx.

{}, m_pTdefMode{}, m_MPIvetoMode{};

m_pTemtMode

int Pythia8::PowhegV_EW::m_pTemtMode {}

private

Definition at line 665 of file PowhegV_EW.cxx.

{}, m_vetoMode{}, m_vetoCount{}, m_pThardMode{}, m_pTemtMode{},

m_pThard

double Pythia8::PowhegV_EW::m_pThard {}

private

Definition at line 667 of file PowhegV_EW.cxx.

{}, m_pTMPI{};

m_pThardMode

int Pythia8::PowhegV_EW::m_pThardMode {}

private

Definition at line 665 of file PowhegV_EW.cxx.

{}, m_vetoMode{}, m_vetoCount{}, m_pThardMode{}, m_pTemtMode{},

m_pTMPI

double Pythia8::PowhegV_EW::m_pTMPI {}

private

Definition at line 667 of file PowhegV_EW.cxx.

{}, m_pTMPI{};

m_si_data_

si_data_type Pythia8::PowhegV_EW::m_si_data_ {}

private

Definition at line 673 of file PowhegV_EW.cxx.

{};

m_si_event_info_

si_event_info_type Pythia8::PowhegV_EW::m_si_event_info_ {}

private

Definition at line 674 of file PowhegV_EW.cxx.

{};

m_vetoCount

int Pythia8::PowhegV_EW::m_vetoCount {}

private

Definition at line 665 of file PowhegV_EW.cxx.

{}, m_vetoMode{}, m_vetoCount{}, m_pThardMode{}, m_pTemtMode{},

m_vetoMode

int Pythia8::PowhegV_EW::m_vetoMode {}

private

Definition at line 665 of file PowhegV_EW.cxx.

{}, m_vetoMode{}, m_vetoCount{}, m_pThardMode{}, m_pTemtMode{},

---

The documentation for this class was generated from the following file:

• PowhegV_EW.cxx