#include <TauolappInterface.h>

Inheritance diagram for gen::TauolappInterface:

Public Member Functions
HepMC::GenEvent *	decay (HepMC::GenEvent *) override

void	disablePolarization () override

void	enablePolarization () override

void	init (const edm::EventSetup &) override

const std::vector< int > &	operatesOnParticles () override

void	SetLHE (lhef::LHEEvent *l) override

void	setRandomEngine (CLHEP::HepRandomEngine *v) override

void	statistics () override

	TauolappInterface (const edm::ParameterSet &, edm::ConsumesCollector)

	~TauolappInterface () override

Public Member Functions inherited from gen::TauolaInterfaceBase
virtual void	SetDecayRandomEngine (CLHEP::HepRandomEngine *decayRandomEngine)

	TauolaInterfaceBase ()

	TauolaInterfaceBase (const edm::ParameterSet &)

virtual	~TauolaInterfaceBase ()

Static Public Member Functions
static double	flat ()

Private Member Functions
void	BoostProdToLabLifeTimeInDecays (HepMC::GenParticle *p, TLorentzVector &lab, TLorentzVector &prod)

void	decodeMDTAU (int)

HepMC::GenParticle *	FirstTauInChain (HepMC::GenParticle *tau)

HepMC::GenParticle *	GetMother (HepMC::GenParticle *tau)

bool	isLastTauInChain (const HepMC::GenParticle *tau)

HepMC::GenEvent *	make_simple_tau_event (const TLorentzVector &l, int pdgid, int status)

double	MatchedLHESpinUp (HepMC::GenParticle *tau, std::vector< HepMC::GenParticle > &p, std::vector< double > &spinup, std::vector< int > &m_idx)

void	selectDecayByMDTAU ()

int	selectHadronic ()

int	selectLeptonic ()

void	update_particles (HepMC::GenParticle partHep, HepMC::GenEvent theEvent, HepMC::GenParticle *p, TVector3 &boost)

Private Attributes
double	dmMatch

bool	dolhe

bool	dolheBosonCorr

std::vector< int >	fHadronModes

bool	fIsInitialized

std::vector< int >	fLeptonModes

int	fMDTAU

std::vector< int >	fPDGs

edm::ESHandle< HepPDT::ParticleDataTable >	fPDGTable

edm::ESGetToken< HepPDT::ParticleDataTable, edm::DefaultRecord >	fPDGTableToken

bool	fPolarization

edm::ParameterSet *	fPSet

std::vector< double >	fScaledHadronBrRatios

std::vector< double >	fScaledLeptonBrRatios

bool	fSelectDecayByEvent

lhef::LHEEvent *	lhe

double	lifetime

int	ntries

Static Private Attributes
static CLHEP::HepRandomEngine *	fRandomEngine = nullptr

Additional Inherited Members
Protected Attributes inherited from gen::TauolaInterfaceBase
std::vector< int >	fPDGs

Detailed Description

Definition at line 28 of file TauolappInterface.h.

Constructor & Destructor Documentation

◆ TauolappInterface()

TauolappInterface::TauolappInterface	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector	iCollector
	)

Definition at line 50 of file TauolappInterface.cc.

References edm::BeginLuminosityBlock, fPSet, and muonDTDigis_cfi::pset.

     : fPolarization(false),
       fPDGTableToken(iCollector.esConsumes<edm::Transition::BeginLuminosityBlock>()),
       fPSet(nullptr),
       fIsInitialized(false),
       fMDTAU(-1),
       fSelectDecayByEvent(false),
       lhe(nullptr),
       dmMatch(0.5),
       dolhe(false),
       dolheBosonCorr(false),
       ntries(10) {
   fPSet = new ParameterSet(pset);
 }

◆ ~TauolappInterface()

TauolappInterface::~TauolappInterface ( )

override

Definition at line 65 of file TauolappInterface.cc.

References fPSet.

                                       {
   if (fPSet != nullptr)
     delete fPSet;
 }

Member Function Documentation

◆ BoostProdToLabLifeTimeInDecays()

void TauolappInterface::BoostProdToLabLifeTimeInDecays	(	HepMC::GenParticle *	p,
		TLorentzVector &	lab,
		TLorentzVector &	prod
	)

private

Definition at line 803 of file TauolappInterface.cc.

References class-composition::children, gen::p, and dumpMFGeometry_cfg::prod.

Referenced by decay().

                                                                              {
   if (p->end_vertex() && p->production_vertex()) {
     HepMC::GenVertex* PGenVtx = p->production_vertex();
     HepMC::GenVertex* EGenVtx = p->end_vertex();
     double VxDec = PGenVtx->position().x() + lab.Px() / prod.Px() * (EGenVtx->position().x() - PGenVtx->position().x());
     double VyDec = PGenVtx->position().y() + lab.Py() / prod.Py() * (EGenVtx->position().y() - PGenVtx->position().y());
     double VzDec = PGenVtx->position().z() + lab.Pz() / prod.Pz() * (EGenVtx->position().z() - PGenVtx->position().z());
     double VtDec = PGenVtx->position().t() + lab.Pt() / prod.Pt() * (EGenVtx->position().t() - PGenVtx->position().t());
     EGenVtx->set_position(HepMC::FourVector(VxDec, VyDec, VzDec, VtDec));
     for (HepMC::GenVertex::particle_iterator dau = p->end_vertex()->particles_begin(HepMC::children);
          dau != p->end_vertex()->particles_end(HepMC::children);
          dau++) {
       BoostProdToLabLifeTimeInDecays((*dau), lab, prod);  //recursively modify everything in the decay chain
     }
   }
 }

◆ decay()

HepMC::GenEvent * TauolappInterface::decay ( HepMC::GenEvent * evt )

overridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 224 of file TauolappInterface.cc.

References funct::abs(), BoostProdToLabLifeTimeInDecays(), class-composition::children, dolhe, dolheBosonCorr, fIsInitialized, flat(), fSelectDecayByEvent, GenParticle::GenParticle, nanoDQM_cfi::GenVtx, lhef::LHEEvent::getHEPEUP(), GetMother(), mps_fire::i, lhef::HEPEUP::IDUP, isLastTauInChain(), lhef::HEPEUP::ISTUP, gpuVertexFinder::iv, dqmiolumiharvest::j, gen::k, lhe, visualization-live-secondInstance_cfg::m, make_simple_tau_event(), MatchedLHESpinUp(), lhef::HEPEUP::MOTHUP, ntries, gen::p, LaserDQM_cfg::p1, parents, ecalTrigSettings_cff::particles, lhef::HEPEUP::PUP, selectDecayByMDTAU(), lhef::HEPEUP::SPINUP, mps_update::status, cmsswSequenceInfo::tp, and update_particles().

                                                           {
   if (!fIsInitialized)
     return evt;
   Tauolapp::Tauola::setRandomGenerator(
       gen::TauolappInterface::flat);  // rest tauola++ random number incase other modules use tauola++
   int NPartBefore = evt->particles_size();
   int NVtxBefore = evt->vertices_size();
 
   // what do we do if Hep::GenEvent size is larger than 10K ???
   // Tauola (& Photos, BTW) can only handle up to 10K via HEPEVT,
   // and in case of CMS, it's only up to 4K !!!
   // override decay mode if needs be
 
   if (fSelectDecayByEvent) {
     selectDecayByMDTAU();
   }
   if (dolhe && lhe != nullptr) {
     std::vector<HepMC::GenParticle> particles;
     std::vector<int> m_idx;
     std::vector<double> spinup = lhe->getHEPEUP()->SPINUP;
     std::vector<int> pdg = lhe->getHEPEUP()->IDUP;
     for (unsigned int i = 0; i < spinup.size(); i++) {
       particles.push_back(HepMC::GenParticle(HepMC::FourVector(lhe->getHEPEUP()->PUP.at(i)[0],
                                                                lhe->getHEPEUP()->PUP.at(i)[1],
                                                                lhe->getHEPEUP()->PUP.at(i)[2],
                                                                lhe->getHEPEUP()->PUP.at(i)[3]),
                                              lhe->getHEPEUP()->IDUP.at(i)));
       int status = lhe->getHEPEUP()->ISTUP.at(i);
       particles.at(particles.size() - 1).set_generated_mass(lhe->getHEPEUP()->PUP.at(i)[4]);
       particles.at(particles.size() - 1).set_status(status > 0 ? (status == 2 ? 3 : status) : 3);
       m_idx.push_back(lhe->getHEPEUP()->MOTHUP.at(i).first - 1);  // correct for fortran index offset
     }
     // match to taus in hepmc and identify mother of taus
     bool hastaus(false);
     std::vector<HepMC::GenParticle*> match;
     for (HepMC::GenEvent::particle_const_iterator iter = evt->particles_begin(); iter != evt->particles_end(); iter++) {
       if (abs((*iter)->pdg_id()) == 15) {
         hastaus = true;
         int mother_pid(0);
         // check imediate parent to avoid parent tau ie tau->taugamma
         for (HepMC::GenVertex::particle_iterator mother = (*iter)->production_vertex()->particles_begin(HepMC::parents);
              mother != (*iter)->production_vertex()->particles_end(HepMC::parents);
              mother++) {
           mother_pid = (*mother)->pdg_id();
           if (mother_pid != (*iter)->pdg_id()) {
             // match against lhe record
             if (abs(mother_pid) == 24 ||  // W
                 abs(mother_pid) == 37 ||  // H+/-
                 abs(mother_pid) == 23 ||  // Z
                 abs(mother_pid) == 22 ||  // gamma
                 abs(mother_pid) == 25 ||  // H0 SM
                 abs(mother_pid) == 35 ||  // H0
                 abs(mother_pid) == 36     // A0
             ) {
               bool isfound = false;
               for (unsigned int k = 0; k < match.size(); k++) {
                 if ((*mother) == match.at(k))
                   isfound = true;
               }
               if (!isfound)
                 match.push_back(*mother);
             }
           }
         }
       }
     }
     if (hastaus) {
       // if is single gauge boson decay and match helicities
       if (match.size() == 1 && dolheBosonCorr) {
         for (int i = 0; i < ntries; i++) {
           // re-decay taus then check if helicities match
           auto* t_event = new Tauolapp::TauolaHepMCEvent(evt);
           t_event->undecayTaus();
           t_event->decayTaus();
           bool ismatch = true;
           for (unsigned int j = 0; j < spinup.size(); j++) {
             if (abs(pdg.at(j)) == 15) {
               double diffhelminus = (-1.0 * (double)Tauolapp::Tauola::getHelMinus() -
                                      spinup.at(j));  // -1.0 to correct for tauola feature
               double diffhelplus = ((double)Tauolapp::Tauola::getHelPlus() - spinup.at(j));
               if (pdg.at(j) == 15 && diffhelminus > 0.5)
                 ismatch = false;
               if (pdg.at(j) == -15 && diffhelplus > 0.5)
                 ismatch = false;
             }
           }
           delete t_event;
           if (ismatch)
             break;
         }
       } else {
         // If the event does not contain a single gauge boson the code will be run with
         // remove all tau decays
         auto* t_event = new Tauolapp::TauolaHepMCEvent(evt);
         t_event->undecayTaus();
         delete t_event;
         // decay all taus manually based on the helicity
         for (HepMC::GenEvent::particle_const_iterator iter = evt->particles_begin(); iter != evt->particles_end();
              iter++) {
           if (abs((*iter)->pdg_id()) == 15 && isLastTauInChain(*iter)) {
             TLorentzVector ltau(
                 (*iter)->momentum().px(), (*iter)->momentum().py(), (*iter)->momentum().pz(), (*iter)->momentum().e());
             HepMC::GenParticle* m = GetMother(*iter);
             TLorentzVector mother(m->momentum().px(), m->momentum().py(), m->momentum().pz(), m->momentum().e());
             TVector3 boost = -1.0 * mother.BoostVector();  // boost into mother's CM frame
             TLorentzVector ltau_lab = ltau;
             ltau.Boost(boost);
             mother.Boost(boost);
             HepMC::GenEvent* tauevt = make_simple_tau_event(ltau, (*iter)->pdg_id(), (*iter)->status());
             HepMC::GenParticle* p = (*(tauevt->particles_begin()));
             Tauolapp::TauolaParticle* tp = new Tauolapp::TauolaHepMCParticle(p);
             double helicity = MatchedLHESpinUp(*iter, particles, spinup, m_idx);  // get helicity from lhe
             if ((*iter)->pdg_id() == 15)
               helicity *= -1.0;
             tp->undecay();
             // use |S_{tau}|=0.999999 to avoid issues with numerical roundoff
             Tauolapp::Tauola::decayOne(tp, true, 0, 0, ((double)helicity) * 0.999999);
             boost *= -1.0;  // boost back to lab frame
             mother.Boost(boost);
             update_particles((*iter), evt, p, boost);
             //correct tau liftetime for boost (change rest frame from mothers to taus)
             BoostProdToLabLifeTimeInDecays((*iter), ltau_lab, ltau);
             delete tauevt;
           }
         }
       }
     }
   } else {
     //construct tmp TAUOLA event
     auto* t_event = new Tauolapp::TauolaHepMCEvent(evt);
     //t_event->undecayTaus();
     t_event->decayTaus();
     delete t_event;
   }
 
   for (int iv = NVtxBefore + 1; iv <= evt->vertices_size(); iv++) {
     HepMC::GenVertex* GenVtx = evt->barcode_to_vertex(-iv);
     //
     // now find decay products with funky barcode, weed out and replace with clones of sensible barcode
     // we can NOT change the barcode while iterating, because iterators do depend on the barcoding
     // thus we have to take a 2-step procedure
     //
     std::vector<int> BCodes;
     BCodes.clear();
     for (HepMC::GenVertex::particle_iterator pitr = GenVtx->particles_begin(HepMC::children);
          pitr != GenVtx->particles_end(HepMC::children);
          ++pitr) {
       if ((*pitr)->barcode() > 10000) {
         BCodes.push_back((*pitr)->barcode());
       }
     }
     if (!BCodes.empty()) {
       for (size_t ibc = 0; ibc < BCodes.size(); ibc++) {
         HepMC::GenParticle* p1 = evt->barcode_to_particle(BCodes[ibc]);
         int nbc = p1->barcode() - 10000 + NPartBefore;
         p1->suggest_barcode(nbc);
       }
     }
   }
 
   for (HepMC::GenEvent::particle_const_iterator p = evt->particles_begin(); p != evt->particles_end(); ++p) {
     if ((*p)->end_vertex() && (*p)->status() == 1)
       (*p)->set_status(2);
     if ((*p)->end_vertex() && (*p)->end_vertex()->particles_out_size() == 0)
       edm::LogWarning("TauolappInterface::decay error: empty end vertex!");
   }
 
   return evt;
 }

◆ decodeMDTAU()

void TauolappInterface::decodeMDTAU ( int mdtau )

private

Definition at line 396 of file TauolappInterface.cc.

References fHadronModes, fLeptonModes, fScaledHadronBrRatios, fScaledLeptonBrRatios, fSelectDecayByEvent, mps_fire::i, and TauolaSettings_cff::mdtau.

Referenced by init().

                                              {
   // Note-1:
   // I have to hack the common block directly because set<...>DecayMode(...)
   // only changes it in the Tauola++ instance but does NOT passes it over
   // to the Fortran core - this it does only one, via initialize() stuff...
   //
   // So I'll do both ways of settings, just for consistency...
   // but I probably need to communicate it to the Tauola(++) team...
   //
 
   // Note-2:
   // originally, the 1xx settings are meant for tau's from hard event,
   // and the 2xx settings are for any tau in the event record;
   //
   // later one, we'll have to take this into account...
   // but first I'll have to sort out what happens in the 1xx case
   // to tau's coming outside of hard event (if any in the record)
   //
 
   if (mdtau == 101 || mdtau == 201) {
     // override with electron mode for both tau's
     //
     Tauolapp::jaki_.jak1 = 1;
     Tauolapp::jaki_.jak2 = 1;
     Tauolapp::Tauola::setSameParticleDecayMode(1);
     Tauolapp::Tauola::setOppositeParticleDecayMode(1);
     return;
   }
 
   if (mdtau == 102 || mdtau == 202) {
     // override with muon mode for both tau's
     //
     Tauolapp::jaki_.jak1 = 2;
     Tauolapp::jaki_.jak2 = 2;
     Tauolapp::Tauola::setSameParticleDecayMode(2);
     Tauolapp::Tauola::setOppositeParticleDecayMode(2);
     return;
   }
 
   if (mdtau == 111 || mdtau == 211) {
     // override with electron mode for 1st tau
     // and any mode for 2nd tau
     //
     Tauolapp::jaki_.jak1 = 1;
     Tauolapp::jaki_.jak2 = 0;
     Tauolapp::Tauola::setSameParticleDecayMode(1);
     Tauolapp::Tauola::setOppositeParticleDecayMode(0);
     return;
   }
 
   if (mdtau == 112 || mdtau == 212) {
     // override with muon mode for the 1st tau
     // and any mode for the 2nd tau
     //
     Tauolapp::jaki_.jak1 = 2;
     Tauolapp::jaki_.jak2 = 0;
     Tauolapp::Tauola::setSameParticleDecayMode(2);
     Tauolapp::Tauola::setOppositeParticleDecayMode(0);
     return;
   }
 
   if (mdtau == 121 || mdtau == 221) {
     // override with any mode for the 1st tau
     // and electron mode for the 2nd tau
     //
     Tauolapp::jaki_.jak1 = 0;
     Tauolapp::jaki_.jak2 = 1;
     Tauolapp::Tauola::setSameParticleDecayMode(0);
     Tauolapp::Tauola::setOppositeParticleDecayMode(1);
     return;
   }
 
   if (mdtau == 122 || mdtau == 222) {
     // override with any mode for the 1st tau
     // and muon mode for the 2nd tau
     //
     Tauolapp::jaki_.jak1 = 0;
     Tauolapp::jaki_.jak2 = 2;
     Tauolapp::Tauola::setSameParticleDecayMode(0);
     Tauolapp::Tauola::setOppositeParticleDecayMode(2);
     return;
   }
 
   if (mdtau == 140 || mdtau == 240) {
     // override with pi+/- nutau mode for both tau's
     //
     Tauolapp::jaki_.jak1 = 3;
     Tauolapp::jaki_.jak2 = 3;
     Tauolapp::Tauola::setSameParticleDecayMode(3);
     Tauolapp::Tauola::setOppositeParticleDecayMode(3);
     return;
   }
 
   if (mdtau == 141 || mdtau == 241) {
     // override with pi+/- nutau mode for the 1st tau
     // and any mode for the 2nd tau
     //
     Tauolapp::jaki_.jak1 = 3;
     Tauolapp::jaki_.jak2 = 0;
     Tauolapp::Tauola::setSameParticleDecayMode(3);
     Tauolapp::Tauola::setOppositeParticleDecayMode(0);
     return;
   }
 
   if (mdtau == 142 || mdtau == 242) {
     // override with any mode for the 1st tau
     // and pi+/- nutau mode for 2nd tau
     //
     Tauolapp::jaki_.jak1 = 0;
     Tauolapp::jaki_.jak2 = 3;
     Tauolapp::Tauola::setSameParticleDecayMode(0);
     Tauolapp::Tauola::setOppositeParticleDecayMode(3);
     return;
   }
 
   // OK, we come here for semi-inclusive modes
   //
 
   // First of all, leptons and hadron modes sums
   //
   // re-scale branching ratios, just in case...
   //
   double sumBra = 0;
 
   // the number of decay modes is hardcoded at 22 because that's what it is right now in Tauola
   // in the future, perhaps an asscess method would be useful - communicate to Tauola team...
   //
 
   for (int i = 0; i < 22; i++) {
     sumBra += Tauolapp::taubra_.gamprt[i];
   }
   if (sumBra == 0.)
     return;  // perhaps need to throw ?
   for (int i = 0; i < 22; i++) {
     double newBra = Tauolapp::taubra_.gamprt[i] / sumBra;
     Tauolapp::Tauola::setTauBr(i + 1, newBra);
   }
   sumBra = 1.0;
 
   double sumLeptonBra = Tauolapp::taubra_.gamprt[0] + Tauolapp::taubra_.gamprt[1];
   double sumHadronBra = sumBra - sumLeptonBra;
 
   for (int i = 0; i < 2; i++) {
     fLeptonModes.push_back(i + 1);
     fScaledLeptonBrRatios.push_back((Tauolapp::taubra_.gamprt[i] / sumLeptonBra));
   }
   for (int i = 2; i < 22; i++) {
     fHadronModes.push_back(i + 1);
     fScaledHadronBrRatios.push_back((Tauolapp::taubra_.gamprt[i] / sumHadronBra));
   }
 
   fSelectDecayByEvent = true;
   return;
 }

◆ disablePolarization()

void gen::TauolappInterface::disablePolarization ( )

inlineoverridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 38 of file TauolappInterface.h.

References fPolarization.

                                         {
       fPolarization = false;
       return;
     }

◆ enablePolarization()

void gen::TauolappInterface::enablePolarization ( )

inlineoverridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 34 of file TauolappInterface.h.

References fPolarization.

                                        {
       fPolarization = true;
       return;
     }

◆ FirstTauInChain()

HepMC::GenParticle * TauolappInterface::FirstTauInChain ( HepMC::GenParticle * tau )

private

Definition at line 776 of file TauolappInterface.cc.

References parents, and metsig::tau.

Referenced by MatchedLHESpinUp().

                                                                           {
   if (tau->production_vertex()) {
     HepMC::GenVertex::particle_iterator mother;
     for (mother = tau->production_vertex()->particles_begin(HepMC::parents);
          mother != tau->production_vertex()->particles_end(HepMC::parents);
          mother++) {
       if ((*mother)->pdg_id() == tau->pdg_id())
         return FirstTauInChain(*mother);  // recursive call to get mother with different pdgid
     }
   }
   return tau;
 }

◆ flat()

double TauolappInterface::flat ( void )

static

Definition at line 214 of file TauolappInterface.cc.

References Exception, and fRandomEngine.

Referenced by decay(), init(), gen::ranmar_(), and selectLeptonic().

                                {
   if (!fRandomEngine) {
     throw cms::Exception("LogicError")
         << "TauolaInterface::flat: Attempt to generate random number when engine pointer is null\n"
         << "This might mean that the code was modified to generate a random number outside the\n"
         << "event and beginLuminosityBlock methods, which is not allowed.\n";
   }
   return fRandomEngine->flat();
 }

◆ GetMother()

HepMC::GenParticle * TauolappInterface::GetMother ( HepMC::GenParticle * tau )

private

Definition at line 789 of file TauolappInterface.cc.

References parents, and metsig::tau.

Referenced by decay(), and MatchedLHESpinUp().

                                                                     {
   if (tau->production_vertex()) {
     HepMC::GenVertex::particle_iterator mother;
     for (mother = tau->production_vertex()->particles_begin(HepMC::parents);
          mother != tau->production_vertex()->particles_end(HepMC::parents);
          mother++) {
       if ((*mother)->pdg_id() == tau->pdg_id())
         return GetMother(*mother);  // recursive call to get mother with different pdgid
       return (*mother);
     }
   }
   return tau;
 }

◆ init()

void TauolappInterface::init ( const edm::EventSetup & es )

overridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 70 of file TauolappInterface.cc.

References funct::abs(), looper::cfg, gather_cfg::cout, decodeMDTAU(), dmMatch, dolhe, dolheBosonCorr, Exception, edm::ParameterSet::exists(), fIsInitialized, flat(), fMDTAU, fPDGs, fPDGTable, fPDGTableToken, fPolarization, fPSet, edm::EventSetup::getHandle(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, initialize(), lifetime, ntries, LHEGenericFilter_cfi::ParticleID, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                     {
   if (fIsInitialized)
     return;  // do init only once
   if (fPSet == nullptr)
     throw cms::Exception("TauolappInterfaceError") << "Attempt to initialize Tauola with an empty ParameterSet\n"
                                                    << std::endl;
 
   fIsInitialized = true;
 
   fPDGTable = es.getHandle(fPDGTableToken);
 
   Tauolapp::Tauola::setDecayingParticle(15);
 
   // LHE Information
   dmMatch = fPSet->getUntrackedParameter<double>("dmMatch", 0.5);
   dolhe = fPSet->getUntrackedParameter<bool>("dolhe", false);
   dolheBosonCorr = fPSet->getUntrackedParameter<bool>("dolheBosonCorr", true);
   ntries = fPSet->getUntrackedParameter<int>("ntries", 10);
 
   // polarization switch
   // fPolarization = fPSet->getParameter<bool>("UseTauolaPolarization") ? 1 : 0 ;
   fPolarization = fPSet->getParameter<bool>("UseTauolaPolarization");
 
   // read tau decay mode switches
   //
   ParameterSet cards = fPSet->getParameter<ParameterSet>("InputCards");
 
   fMDTAU = cards.getParameter<int>("mdtau");
 
   if (fMDTAU == 0 || fMDTAU == 1) {
     Tauolapp::Tauola::setSameParticleDecayMode(cards.getParameter<int>("pjak1"));
     Tauolapp::Tauola::setOppositeParticleDecayMode(cards.getParameter<int>("pjak2"));
   }
 
   Tauolapp::Tauola::spin_correlation.setAll(fPolarization);
 
   // some more options, copied over from an example
   // Default values
   //Tauola::setEtaK0sPi(0,0,0); // switches to decay eta K0_S and pi0 1/0 on/off.
 
   const HepPDT::ParticleData* PData =
       fPDGTable->particle(HepPDT::ParticleID(abs(Tauolapp::Tauola::getDecayingParticle())));
   double lifetime = PData->lifetime().value();
   Tauolapp::Tauola::setTauLifetime(lifetime);
 
   fPDGs.push_back(Tauolapp::Tauola::getDecayingParticle());
 
   Tauolapp::Tauola::setRandomGenerator(gen::TauolappInterface::flat);
 
   if (fPSet->exists("parameterSets")) {
     std::vector<std::string> par = fPSet->getParameter<std::vector<std::string> >("parameterSets");
     for (unsigned int ip = 0; ip < par.size(); ++ip) {
       std::string curSet = par[ip];
       if (curSet == "setNewCurrents")
         Tauolapp::Tauola::setNewCurrents(fPSet->getParameter<int>(curSet));
     }
   }
 
   Tauolapp::Tauola::initialize();
 
   Tauolapp::Tauola::spin_correlation.setAll(
       fPolarization);  // Tauola switches this on during Tauola::initialise(); so we add this here to keep it on/off
 
   if (fPSet->exists("parameterSets")) {
     std::vector<std::string> par = fPSet->getParameter<std::vector<std::string> >("parameterSets");
     for (unsigned int ip = 0; ip < par.size(); ++ip) {
       std::string curSet = par[ip];
       if (curSet == "spinCorrelationSetAll")
         Tauolapp::Tauola::spin_correlation.setAll(fPSet->getParameter<bool>(curSet));
       if (curSet == "spinCorrelationGAMMA")
         Tauolapp::Tauola::spin_correlation.GAMMA = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationZ0")
         Tauolapp::Tauola::spin_correlation.Z0 = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationHIGGS")
         Tauolapp::Tauola::spin_correlation.HIGGS = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationHIGGSH")
         Tauolapp::Tauola::spin_correlation.HIGGS_H = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationHIGGSA")
         Tauolapp::Tauola::spin_correlation.HIGGS_A = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationHIGGSPLUS")
         Tauolapp::Tauola::spin_correlation.HIGGS_PLUS = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationHIGGSMINUS")
         Tauolapp::Tauola::spin_correlation.HIGGS_MINUS = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationWPLUS")
         Tauolapp::Tauola::spin_correlation.W_PLUS = fPSet->getParameter<bool>(curSet);
       if (curSet == "spinCorrelationWMINUS")
         Tauolapp::Tauola::spin_correlation.W_MINUS = fPSet->getParameter<bool>(curSet);
 
       if (curSet == "setHiggsScalarPseudoscalarPDG")
         Tauolapp::Tauola::setHiggsScalarPseudoscalarPDG(fPSet->getParameter<int>(curSet));
       if (curSet == "setHiggsScalarPseudoscalarMixingAngle")
         Tauolapp::Tauola::setHiggsScalarPseudoscalarMixingAngle(fPSet->getParameter<double>(curSet));
 
       if (curSet == "setRadiation")
         Tauolapp::Tauola::setRadiation(fPSet->getParameter<bool>(curSet));
       if (curSet == "setRadiationCutOff")
         Tauolapp::Tauola::setRadiationCutOff(fPSet->getParameter<double>(curSet));
 
       if (curSet == "setEtaK0sPi") {
         std::vector<int> vpar = fPSet->getParameter<std::vector<int> >(curSet);
         if (vpar.size() == 3)
           Tauolapp::Tauola::setEtaK0sPi(vpar[0], vpar[1], vpar[2]);
         else {
           std::cout << "WARNING invalid size for setEtaK0sPi: " << vpar.size() << " Require 3 elements " << std::endl;
         }
       }
 
       if (curSet == "setTaukle") {
         std::vector<double> vpar = fPSet->getParameter<std::vector<double> >(curSet);
         if (vpar.size() == 4)
           Tauolapp::Tauola::setTaukle(vpar[0], vpar[1], vpar[2], vpar[3]);
         else {
           std::cout << "WARNING invalid size for setTaukle: " << vpar.size() << " Require 4 elements " << std::endl;
         }
       }
 
       if (curSet == "setTauBr") {
         edm::ParameterSet cfg = fPSet->getParameter<edm::ParameterSet>(curSet);
         std::vector<int> vJAK = cfg.getParameter<std::vector<int> >("JAK");
         std::vector<double> vBR = cfg.getParameter<std::vector<double> >("BR");
         if (vJAK.size() == vBR.size()) {
           for (unsigned int i = 0; i < vJAK.size(); i++)
             Tauolapp::Tauola::setTauBr(vJAK[i], vBR[i]);
         } else {
           std::cout << "WARNING invalid size for setTauBr - JAK: " << vJAK.size() << " BR: " << vBR.size() << std::endl;
         }
       }
     }
   }
 
   // override decay modes if needs be
   //
   // we have to do it AFTER init because otherwises branching ratios are NOT filled in
   //
   if (fMDTAU != 0 && fMDTAU != 1) {
     decodeMDTAU(fMDTAU);
   }
 
   Tauolapp::Log::LogWarning(false);
   Tauolapp::Log::IgnoreRedirection(true);
 
   return;
 }

◆ isLastTauInChain()

bool TauolappInterface::isLastTauInChain ( const HepMC::GenParticle * tau )

private

Definition at line 739 of file TauolappInterface.cc.

References class-composition::children, and metsig::tau.

Referenced by decay().

                                                                     {
   if (tau->end_vertex()) {
     HepMC::GenVertex::particle_iterator dau;
     for (dau = tau->end_vertex()->particles_begin(HepMC::children);
          dau != tau->end_vertex()->particles_end(HepMC::children);
          dau++) {
       int dau_pid = (*dau)->pdg_id();
       if (dau_pid == tau->pdg_id())
         return false;
     }
   }
   return true;
 }

◆ make_simple_tau_event()

HepMC::GenEvent * TauolappInterface::make_simple_tau_event	(	const TLorentzVector &	l,
		int	pdgid,
		int	status
	)

private

Definition at line 697 of file TauolappInterface.cc.

References edmPickEvents::event, GenParticle::GenParticle, MainPageGenerator::l, EgammaValidation_cff::pdgid, mps_update::status, jetsAK8_cff::tau1, and bphysicsOniaDQM_cfi::vertex.

Referenced by decay().

                                                                                                       {
   HepMC::GenEvent* event = new HepMC::GenEvent();
   // make tau's four vector
   HepMC::FourVector momentum_tau1(l.Px(), l.Py(), l.Pz(), l.E());
   // make particles
   HepMC::GenParticle* tau1 = new HepMC::GenParticle(momentum_tau1, pdgid, status);
   // make the vertex
   HepMC::GenVertex* vertex = new HepMC::GenVertex();
   vertex->add_particle_out(tau1);
   event->add_vertex(vertex);
   return event;
 }

◆ MatchedLHESpinUp()

double TauolappInterface::MatchedLHESpinUp	(	HepMC::GenParticle *	tau,
		std::vector< HepMC::GenParticle > &	p,
		std::vector< double > &	spinup,
		std::vector< int > &	m_idx
	)

private

Definition at line 753 of file TauolappInterface.cc.

References dmMatch, FirstTauInChain(), GenParticle::GenParticle, GetMother(), mps_fire::i, visualization-live-secondInstance_cfg::m, gen::p, HiggsValidation_cfi::pdg_id, submitPVValidationJobs::t, and metsig::tau.

Referenced by decay().

                                                                   {
   HepMC::GenParticle* Tau = FirstTauInChain(tau);
   HepMC::GenParticle* mother = GetMother(Tau);
   TLorentzVector t(tau->momentum().px(), tau->momentum().py(), tau->momentum().pz(), tau->momentum().e());
   TLorentzVector m(mother->momentum().px(), mother->momentum().py(), mother->momentum().pz(), mother->momentum().e());
   for (unsigned int i = 0; i < p.size(); i++) {
     if (tau->pdg_id() == p.at(i).pdg_id()) {
       if (mother->pdg_id() == p.at(m_idx.at(i)).pdg_id()) {
         TLorentzVector pm(p.at(m_idx.at(i)).momentum().px(),
                           p.at(m_idx.at(i)).momentum().py(),
                           p.at(m_idx.at(i)).momentum().pz(),
                           p.at(m_idx.at(i)).momentum().e());
         if (fabs(m.M() - pm.M()) < dmMatch)
           return spinup.at(i);
       }
     }
   }
   return 0;
 }

◆ operatesOnParticles()

const std::vector<int>& gen::TauolappInterface::operatesOnParticles ( )

inlineoverridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 43 of file TauolappInterface.h.

References fPDGs.

43 { return fPDGs; }

gen::TauolappInterface::fPDGs

std::vector< int > fPDGs

Definition: TauolappInterface.h:73

◆ selectDecayByMDTAU()

void TauolappInterface::selectDecayByMDTAU ( )

private

Definition at line 551 of file TauolappInterface.cc.

References fMDTAU, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, selectHadronic(), and selectLeptonic().

Referenced by decay().

                                            {
   if (fMDTAU == 100 || fMDTAU == 200) {
     int mode = selectLeptonic();
     Tauolapp::jaki_.jak1 = mode;
     Tauolapp::Tauola::setSameParticleDecayMode(mode);
     mode = selectLeptonic();
     Tauolapp::jaki_.jak2 = mode;
     Tauolapp::Tauola::setOppositeParticleDecayMode(mode);
     return;
   }
 
   int modeL = selectLeptonic();
   int modeH = selectHadronic();
 
   if (fMDTAU == 110 || fMDTAU == 210) {
     Tauolapp::jaki_.jak1 = modeL;
     Tauolapp::jaki_.jak2 = 0;
     Tauolapp::Tauola::setSameParticleDecayMode(modeL);
     Tauolapp::Tauola::setOppositeParticleDecayMode(0);
     return;
   }
 
   if (fMDTAU == 120 || fMDTAU == 22) {
     Tauolapp::jaki_.jak1 = 0;
     Tauolapp::jaki_.jak2 = modeL;
     Tauolapp::Tauola::setSameParticleDecayMode(0);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeL);
     return;
   }
 
   if (fMDTAU == 114 || fMDTAU == 214) {
     Tauolapp::jaki_.jak1 = modeL;
     Tauolapp::jaki_.jak2 = modeH;
     Tauolapp::Tauola::setSameParticleDecayMode(modeL);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeH);
     return;
   }
 
   if (fMDTAU == 124 || fMDTAU == 224) {
     Tauolapp::jaki_.jak1 = modeH;
     Tauolapp::jaki_.jak2 = modeL;
     Tauolapp::Tauola::setSameParticleDecayMode(modeH);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeL);
     return;
   }
 
   if (fMDTAU == 115 || fMDTAU == 215) {
     Tauolapp::jaki_.jak1 = 1;
     Tauolapp::jaki_.jak2 = modeH;
     Tauolapp::Tauola::setSameParticleDecayMode(1);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeH);
     return;
   }
 
   if (fMDTAU == 125 || fMDTAU == 225) {
     Tauolapp::jaki_.jak1 = modeH;
     Tauolapp::jaki_.jak2 = 1;
     Tauolapp::Tauola::setSameParticleDecayMode(modeH);
     Tauolapp::Tauola::setOppositeParticleDecayMode(1);
     return;
   }
 
   if (fMDTAU == 116 || fMDTAU == 216) {
     Tauolapp::jaki_.jak1 = 2;
     Tauolapp::jaki_.jak2 = modeH;
     Tauolapp::Tauola::setSameParticleDecayMode(2);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeH);
     return;
   }
 
   if (fMDTAU == 126 || fMDTAU == 226) {
     Tauolapp::jaki_.jak1 = modeH;
     Tauolapp::jaki_.jak2 = 2;
     Tauolapp::Tauola::setSameParticleDecayMode(modeH);
     Tauolapp::Tauola::setOppositeParticleDecayMode(2);
     return;
   }
 
   if (fMDTAU == 130 || fMDTAU == 230) {
     Tauolapp::jaki_.jak1 = modeH;
     Tauolapp::jaki_.jak2 = selectHadronic();
     Tauolapp::Tauola::setSameParticleDecayMode(modeH);
     Tauolapp::Tauola::setOppositeParticleDecayMode(Tauolapp::jaki_.jak2);
     return;
   }
 
   if (fMDTAU == 131 || fMDTAU == 231) {
     Tauolapp::jaki_.jak1 = modeH;
     Tauolapp::jaki_.jak2 = 0;
     Tauolapp::Tauola::setSameParticleDecayMode(modeH);
     Tauolapp::Tauola::setOppositeParticleDecayMode(0);
     return;
   }
 
   if (fMDTAU == 132 || fMDTAU == 232) {
     Tauolapp::jaki_.jak1 = 0;
     Tauolapp::jaki_.jak2 = modeH;
     Tauolapp::Tauola::setSameParticleDecayMode(0);
     Tauolapp::Tauola::setOppositeParticleDecayMode(modeH);
     return;
   }
 
   // unlikely that we get here on unknown mdtau
   // - there's a protection earlier
   // but if we do, just set defaults
   // probably need to spit a warning...
   //
   Tauolapp::Tauola::setSameParticleDecayMode(0);
   Tauolapp::Tauola::setOppositeParticleDecayMode(0);
 
   return;
 }

◆ selectHadronic()

int TauolappInterface::selectHadronic ( )

private

Definition at line 676 of file TauolappInterface.cc.

References fHadronModes, fScaledHadronBrRatios, mps_fire::i, mkfit::NN, TtFullHadEvtBuilder_cfi::prob, and gen::ranmar_().

Referenced by selectDecayByMDTAU().

                                       {
   float prob = 0.;
   int len = 1;
   ranmar_(&prob, &len);
 
   double sumBra = fScaledHadronBrRatios[0];
   if (prob > 0. && prob <= sumBra) {
     return fHadronModes[0];
   } else {
     int NN = fScaledHadronBrRatios.size();
     for (int i = 1; i < NN; i++) {
       if (prob > sumBra && prob <= (sumBra + fScaledHadronBrRatios[i])) {
         return fHadronModes[i];
       }
       sumBra += fScaledHadronBrRatios[i];
     }
   }
 
   return 0;
 }

◆ selectLeptonic()

int TauolappInterface::selectLeptonic ( )

private

Definition at line 664 of file TauolappInterface.cc.

References flat(), fScaledLeptonBrRatios, and TtFullHadEvtBuilder_cfi::prob.

Referenced by selectDecayByMDTAU().

                                       {
   float prob = flat();
 
   if (prob > 0. && prob <= fScaledLeptonBrRatios[0]) {
     return 1;
   } else if (prob > fScaledLeptonBrRatios[1] && prob <= 1.) {
     return 2;
   }
 
   return 0;
 }

◆ SetLHE()

void gen::TauolappInterface::SetLHE ( lhef::LHEEvent * l )

inlineoverridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 46 of file TauolappInterface.h.

References MainPageGenerator::l, and lhe.

46 { lhe = l; }

gen::TauolappInterface::lhe

lhef::LHEEvent * lhe

Definition: TauolappInterface.h:86

MainPageGenerator.l

l

Definition: MainPageGenerator.py:429

◆ setRandomEngine()

void gen::TauolappInterface::setRandomEngine ( CLHEP::HepRandomEngine * v )

inlineoverridevirtual

Implements gen::TauolaInterfaceBase.

Definition at line 47 of file TauolappInterface.h.

References fRandomEngine, and gen::v.

47 { fRandomEngine = v; }

gen::v

double v[5][pyjets_maxn]

Definition: Pythia6Hadronizer.cc:89

gen::TauolappInterface::fRandomEngine

static CLHEP::HepRandomEngine * fRandomEngine

Definition: TauolappInterface.h:72

◆ statistics()

void TauolappInterface::statistics ( )

overridevirtual

Reimplemented from gen::TauolaInterfaceBase.

Definition at line 394 of file TauolappInterface.cc.

394 { return; }

◆ update_particles()

void TauolappInterface::update_particles	(	HepMC::GenParticle *	partHep,
		HepMC::GenEvent *	theEvent,
		HepMC::GenParticle *	p,
		TVector3 &	boost
	)

private

Definition at line 710 of file TauolappInterface.cc.

References ztail::d, GenParticle::GenParticle, MainPageGenerator::l, gen::p, and extraflags_cff::vtx.

Referenced by decay().

                                                           {
   partHep->set_status(p->status());
   if (p->end_vertex()) {
     if (!partHep->end_vertex()) {
       HepMC::GenVertex* vtx = new HepMC::GenVertex(p->end_vertex()->position());
       theEvent->add_vertex(vtx);
       vtx->add_particle_in(partHep);
     }
     if (p->end_vertex()->particles_out_size() != 0) {
       for (HepMC::GenVertex::particles_out_const_iterator d = p->end_vertex()->particles_out_const_begin();
            d != p->end_vertex()->particles_out_const_end();
            d++) {
         // Create daughter and add to event
         TLorentzVector l((*d)->momentum().px(), (*d)->momentum().py(), (*d)->momentum().pz(), (*d)->momentum().e());
         l.Boost(boost);
         HepMC::FourVector momentum(l.Px(), l.Py(), l.Pz(), l.E());
         HepMC::GenParticle* daughter = new HepMC::GenParticle(momentum, (*d)->pdg_id(), (*d)->status());
         daughter->suggest_barcode(theEvent->particles_size() + 1);
         partHep->end_vertex()->add_particle_out(daughter);
         if ((*d)->end_vertex())
           update_particles(daughter, theEvent, (*d), boost);
       }
     }
   }
 }

Member Data Documentation

◆ dmMatch

double gen::TauolappInterface::dmMatch

private

Definition at line 88 of file TauolappInterface.h.

Referenced by init(), and MatchedLHESpinUp().

◆ dolhe

bool gen::TauolappInterface::dolhe

private

Definition at line 89 of file TauolappInterface.h.

Referenced by decay(), and init().

◆ dolheBosonCorr

bool gen::TauolappInterface::dolheBosonCorr

private

Definition at line 90 of file TauolappInterface.h.

Referenced by decay(), and init().

◆ fHadronModes

std::vector<int> gen::TauolappInterface::fHadronModes

private

Definition at line 83 of file TauolappInterface.h.

Referenced by decodeMDTAU(), and selectHadronic().

◆ fIsInitialized

bool gen::TauolappInterface::fIsInitialized

private

Definition at line 78 of file TauolappInterface.h.

Referenced by decay(), and init().

◆ fLeptonModes

std::vector<int> gen::TauolappInterface::fLeptonModes

private

Definition at line 82 of file TauolappInterface.h.

Referenced by decodeMDTAU().

◆ fMDTAU

int gen::TauolappInterface::fMDTAU

private

Definition at line 80 of file TauolappInterface.h.

Referenced by init(), and selectDecayByMDTAU().

◆ fPDGs

std::vector<int> gen::TauolappInterface::fPDGs

private

Definition at line 73 of file TauolappInterface.h.

Referenced by init(), and operatesOnParticles().

◆ fPDGTable

edm::ESHandle<HepPDT::ParticleDataTable> gen::TauolappInterface::fPDGTable

private

Definition at line 75 of file TauolappInterface.h.

Referenced by init().

◆ fPDGTableToken

edm::ESGetToken<HepPDT::ParticleDataTable, edm::DefaultRecord> gen::TauolappInterface::fPDGTableToken

private

Definition at line 76 of file TauolappInterface.h.

Referenced by init().

◆ fPolarization

bool gen::TauolappInterface::fPolarization

private

Definition at line 74 of file TauolappInterface.h.

Referenced by disablePolarization(), enablePolarization(), and init().

◆ fPSet

edm::ParameterSet* gen::TauolappInterface::fPSet

private

Definition at line 77 of file TauolappInterface.h.

Referenced by init(), TauolappInterface(), and ~TauolappInterface().

◆ fRandomEngine

CLHEP::HepRandomEngine * TauolappInterface::fRandomEngine = nullptr

staticprivate

Definition at line 72 of file TauolappInterface.h.

Referenced by flat(), and setRandomEngine().

◆ fScaledHadronBrRatios

std::vector<double> gen::TauolappInterface::fScaledHadronBrRatios

private

Definition at line 85 of file TauolappInterface.h.

Referenced by decodeMDTAU(), and selectHadronic().

◆ fScaledLeptonBrRatios

std::vector<double> gen::TauolappInterface::fScaledLeptonBrRatios

private

Definition at line 84 of file TauolappInterface.h.

Referenced by decodeMDTAU(), and selectLeptonic().

◆ fSelectDecayByEvent

bool gen::TauolappInterface::fSelectDecayByEvent

private

Definition at line 81 of file TauolappInterface.h.

Referenced by decay(), and decodeMDTAU().

◆ lhe

lhef::LHEEvent* gen::TauolappInterface::lhe

private

Definition at line 86 of file TauolappInterface.h.

Referenced by decay(), and SetLHE().

◆ lifetime

double gen::TauolappInterface::lifetime

private

Definition at line 92 of file TauolappInterface.h.

Referenced by init().

◆ ntries

int gen::TauolappInterface::ntries

private

Definition at line 91 of file TauolappInterface.h.

Referenced by decay(), and init().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TauolappInterface()

◆ ~TauolappInterface()

Member Function Documentation

◆ BoostProdToLabLifeTimeInDecays()

◆ decay()

◆ decodeMDTAU()

◆ disablePolarization()

◆ enablePolarization()

◆ FirstTauInChain()

◆ flat()

◆ GetMother()

◆ init()

◆ isLastTauInChain()

◆ make_simple_tau_event()

◆ MatchedLHESpinUp()

◆ operatesOnParticles()

◆ selectDecayByMDTAU()

◆ selectHadronic()

◆ selectLeptonic()

◆ SetLHE()

◆ setRandomEngine()

◆ statistics()

◆ update_particles()

Member Data Documentation

◆ dmMatch

◆ dolhe

◆ dolheBosonCorr

◆ fHadronModes

◆ fIsInitialized

◆ fLeptonModes

◆ fMDTAU

◆ fPDGs

◆ fPDGTable

◆ fPDGTableToken

◆ fPolarization

◆ fPSet

◆ fRandomEngine

◆ fScaledHadronBrRatios

◆ fScaledLeptonBrRatios

◆ fSelectDecayByEvent

◆ lhe

◆ lifetime

◆ ntries