diff --git a/.hgtags b/.hgtags --- a/.hgtags +++ b/.hgtags @@ -1,76 +1,80 @@ 041cc049512ed9767d0d7c7344f407b0deeaec48 rivet-1.0 04c9104bf67af2da8be8233e6eb74e10e72a619a rivet-1.1.0 1bd1ee1b351d0ed85484dd0940e9c914c4b52a92 rivet-1.8.0 49417ad8f75595e5661093ce29ef6bc4c33c28ae rivet-1.1.1 4c7765c4ae989d6ffc44eaacac042d5e288fdb28 rivet-1.2.0a0 67fd1c15dd92810c0dd09a694e8d17fd4b08ffcf rivet-0.9 68c1d049c8bca48506145cc5fd8349de637ced77 rivet-1.8.2 70bc4e373609b4be88f0966d7adef6556badadc6 rivet-1.2.0 85f9fb654f4c6ae445688a65472f305d4a4d615a rivet-1.2.0rc1 879cbee6e5bfac7a6c218c95a5e853187fd9117b rivet-0.9b1 886bd3d6ec6b598c602093905493925b55e7eee9 rivet-1.8.1 88f72c595dbb82679cc44370b75b1802a529b45e rivet-1.1.2 8919564de90c325a72cd20a3711319fd96cb8d86 rivet-1.5.1 8dfaacabef9d08b8395f3da982bd83bd2e3f681e rivet-1.6.0 92ea72f0626e6113c17df3965f5faf25408a62f7 rivet-1.2.1 a3846123635d334e30312b0df5b35b3349d0c960 rivet-1.1.3 ac2363d7b563b8498ac0c34954d227433e0aa394 rivet-1.7.0 b6c491e282cc50598e3d6e76dedeb67542827445 rivet-1.4.0 cd1be037b3ec1e8562180430b4d1b5546147eb5e rivet-1.8.3 d1ceb2511be7d0589fc97c466e13b77f8ecc9365 rivet-1.0b2 ddd059260df5a43048f0ac86b9adfdc6407e5c17 rivet-2.0.0b1 ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.1.1 ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.2a0 f18173885a8f037676421516beb2e5a10b27c867 rivet-1.5.0 fe4cd71dee85bacc537c0b4c11574b61c819940e rivet-1.3.0 114301d50bf5a1993dd2cde22a410710cf619016 rivet-2.0.0b2 a01c3ec46a56c6ab8eecf24c410a7a296dc6f721 rivet-2.0.0b3 746bd5fac0b6a6d25358fad141055e98dbffdeb0 rivet-2.0.0 ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.2a0 0000000000000000000000000000000000000000 rivet-1.2.2a0 a01c3ec46a56c6ab8eecf24c410a7a296dc6f721 rivet-2.0.0b3 0000000000000000000000000000000000000000 rivet-2.0.0b3 114301d50bf5a1993dd2cde22a410710cf619016 rivet-2.0.0b2 0000000000000000000000000000000000000000 rivet-2.0.0b2 ddd059260df5a43048f0ac86b9adfdc6407e5c17 rivet-2.0.0b1 0000000000000000000000000000000000000000 rivet-2.0.0b1 ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.1.1 0000000000000000000000000000000000000000 rivet-1.2.1.1 85f9fb654f4c6ae445688a65472f305d4a4d615a rivet-1.2.0rc1 0000000000000000000000000000000000000000 rivet-1.2.0rc1 4c7765c4ae989d6ffc44eaacac042d5e288fdb28 rivet-1.2.0a0 0000000000000000000000000000000000000000 rivet-1.2.0a0 d1ceb2511be7d0589fc97c466e13b77f8ecc9365 rivet-1.0b2 0000000000000000000000000000000000000000 rivet-1.0b2 879cbee6e5bfac7a6c218c95a5e853187fd9117b rivet-0.9b1 0000000000000000000000000000000000000000 rivet-0.9b1 5fc2379981180bb3985e6c7edf7ddb5bc906df21 rivet-2.1.0 7452e4ce7d772698dd840a31d2f39467ad529211 rivet-2.1.1 6b735bb5801b935c3eefa03d651e328a967c2e5f rivet-2.1.2 974b3c3e84ea2f09cd39750a2facfd7e9726209b rivet-2.2.0beta1 96aa6bd1c36a0891fb6a620919920090505466ef rivet-2.2.0 974b3c3e84ea2f09cd39750a2facfd7e9726209b rivet-2.2.0beta1 0000000000000000000000000000000000000000 rivet-2.2.0beta1 805d410d6fadd4efb8d0e6bdf5a930ec0fc1e848 rivet-2.2.1 086c7cd50a1906839b8440845077a39a0279ebb0 rivet-2.3.0 c77ff1b297a71e9ec14440cd2e549fb1c4924148 rivet-2.4.0 6bec638a1eb96ff0b1e18b4f6d62ef96bff40888 rivet-2.4.1 c91d27b41c5a7084f79ede52ae03588a72529c4b rivet-2.4.2 28324a9ab8e39c73376934594e08f872bc442a76 rivet-2.4.3 af77fa6d1c6408c7d8d70ff681996ee614cc6117 rivet-2.5.0beta1 e46470f99190ee58a8f5cbc4c9788867e6b06d30 rivet-2.5.0beta2 6342afb6b879ed61b8988c4521480a9f8406e1aa rivet-2.5.0 af77fa6d1c6408c7d8d70ff681996ee614cc6117 rivet-2.5.0beta1 0000000000000000000000000000000000000000 rivet-2.5.0beta1 e46470f99190ee58a8f5cbc4c9788867e6b06d30 rivet-2.5.0beta2 0000000000000000000000000000000000000000 rivet-2.5.0beta2 afdfca08d4df8a7a80ef980f4fd9324fa6a0263f rivet-2.5.1 7ff482331c2ee005b60d6e4e9bb88dd523de3dc4 rivet-2.5.2 7ff482331c2ee005b60d6e4e9bb88dd523de3dc4 rivet-2.5.2 0000000000000000000000000000000000000000 rivet-2.5.2 0000000000000000000000000000000000000000 rivet-2.5.2 8a05acecd26c18f368f4b748da2d5aa2db46be6c rivet-2.5.2 ad44338e2fa10dd81e2b306545b801ce53f31921 rivet-2.5.3 d16ae7b046d6d448dc70d23dafcce12626eb47c9 rivet-2.5.4 0fa6eb1b4cc025984da306968ba88ba602c90fc7 rivet-2.6.0 2277c130f7e2ca07fbbdd6e5d21e48d8566c6c9b rivet-2.6.1 +2277c130f7e2ca07fbbdd6e5d21e48d8566c6c9b rivet-2.6.1 +0000000000000000000000000000000000000000 rivet-2.6.1 +0000000000000000000000000000000000000000 rivet-2.6.1 +b4c7326193e044f1156a53ecaa8d94583817f9b1 rivet-2.6.1 diff --git a/analyses/pluginATLAS/ATLAS_2018_I1646686.cc b/analyses/pluginATLAS/ATLAS_2018_I1646686.cc --- a/analyses/pluginATLAS/ATLAS_2018_I1646686.cc +++ b/analyses/pluginATLAS/ATLAS_2018_I1646686.cc @@ -1,299 +1,299 @@ // -*- C++ -*- #include "Rivet/Analysis.hh" #include "Rivet/Projections/FinalState.hh" #include "Rivet/Projections/VetoedFinalState.hh" #include "Rivet/Projections/IdentifiedFinalState.hh" #include "Rivet/Projections/PromptFinalState.hh" #include "Rivet/Projections/DressedLeptons.hh" #include "Rivet/Projections/FastJets.hh" #include "Rivet/Projections/PartonicTops.hh" #include "Rivet/Math/LorentzTrans.hh" namespace Rivet { + /// @brief All-hadronic ttbar at 13 TeV class ATLAS_2018_I1646686 : public Analysis { + public: - public: /// Constructor - /// @brief all-hadronic ttbar at 13 TeV DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2018_I1646686); /// Book histograms and initialise projections before the run void init() { //histogram booking book(_h["inclusive"],2,1,1); bookHistograms("t_y", 1, true); bookHistograms("t_pt", 2, true); bookHistograms("t1_pt", 3); bookHistograms("t1_y", 4); bookHistograms("t2_pt", 5); bookHistograms("t2_y", 6); bookHistograms("tt_m", 7); bookHistograms("tt_pt", 8); bookHistograms("tt_y", 9); bookHistograms("tt_chi", 10); bookHistograms("tt_yboost", 11); bookHistograms("tt_pout", 12); bookHistograms("tt_dPhi", 13); bookHistograms("tt_Ht", 14); bookHistograms("tt_cosThStar", 15); // Projections Cut dressed_lep = (Cuts::abseta < 2.5) && (Cuts::pT >= 25*GeV); Cut eta_full = (Cuts::abseta < 5.0); // All final state particles FinalState fs(eta_full); // Get photons to dress leptons IdentifiedFinalState photons(fs); photons.acceptIdPair(PID::PHOTON); // Projection to find the electrons IdentifiedFinalState el_id(fs); el_id.acceptIdPair(PID::ELECTRON); PromptFinalState electrons(el_id); electrons.acceptTauDecays(true); DressedLeptons dressedelectrons(photons, electrons, 0.1, dressed_lep); declare(dressedelectrons, "elecs"); DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full); // Projection to find the muons IdentifiedFinalState mu_id(fs); mu_id.acceptIdPair(PID::MUON); PromptFinalState muons(mu_id); muons.acceptTauDecays(true); DressedLeptons dressedmuons(photons, muons, 0.1, dressed_lep); declare(dressedmuons, "muons"); DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full); // Projection to find neutrinos for vetoing in jets IdentifiedFinalState nu_id(fs); nu_id.acceptNeutrinos(); PromptFinalState neutrinos(nu_id); neutrinos.acceptTauDecays(true); // Jet clustering. VetoedFinalState lvfs(fs); lvfs.addVetoOnThisFinalState(mu_id); lvfs.addVetoOnThisFinalState(nu_id); VetoedFinalState vfs; vfs.addVetoOnThisFinalState(ewdressedelectrons); vfs.addVetoOnThisFinalState(ewdressedmuons); vfs.addVetoOnThisFinalState(neutrinos); FastJets jets(vfs, FastJets::ANTIKT, 0.4); jets.useInvisibles(); declare(jets, "jets"); FastJets ljets(lvfs, FastJets::ANTIKT, 1.0); ljets.useInvisibles(); declare(ljets, "ljets" ); PartonicTops partonTops; declare(partonTops, "partonicTops"); } void analyze(const Event& event) { // Parton-level top quarks const Particles partonicTops = apply( event, "partonicTops").particlesByPt(); FourMomentum top, tbar; bool foundT = false, foundTBar = false; for (const Particle& ptop : partonicTops) { const int pid = ptop.pid(); if (pid == PID::TQUARK) { top = ptop.momentum(); foundT = true; } else if (pid == -PID::TQUARK) { tbar = ptop.momentum(); foundTBar = true; } } FourMomentum t1_parton, t2_parton, ttbar_parton; if ( foundT && foundTBar ) { t1_parton = top.pT2() > tbar.pT2() ? top : tbar; t2_parton = top.pT2() > tbar.pT2() ? tbar : top; ttbar_parton = t1_parton + t2_parton; if ( t1_parton.pT() > 500*GeV && t2_parton.pT() > 350*GeV) { const double chi_parton = calcChi(t1_parton, t2_parton); const double cosThetaStar_parton = abs(calcCosThetaStar(t1_parton, t2_parton)); const double pout_parton = abs(calcPout(t1_parton, t2_parton)); const double dPhi_parton = deltaPhi(t1_parton, t2_parton); const int randomChoice = rand() % 2; const FourMomentum& randomTopParton = (randomChoice == 0) ? t1_parton : t2_parton; fillParton("t_pt", randomTopParton.pT()/GeV); fillParton("t_y", randomTopParton.absrap()); fillParton("t1_pt", t1_parton.pT()/GeV); fillParton("t1_y", t1_parton.absrap()); fillParton("t2_pt", t2_parton.pT()/GeV); fillParton("t2_y", t2_parton.absrap()); fillParton("tt_m", ttbar_parton.mass()/GeV); fillParton("tt_pt", ttbar_parton.pT()/GeV); fillParton("tt_Ht", (t1_parton.pT() + t2_parton.pT())/GeV); fillParton("tt_y", ttbar_parton.absrap()); fillParton("tt_yboost", 0.5 * abs(t1_parton.rapidity() + t2_parton.rapidity())); fillParton("tt_chi", chi_parton); fillParton("tt_cosThStar", cosThetaStar_parton); fillParton("tt_pout", pout_parton/GeV); fillParton("tt_dPhi", dPhi_parton); } } // Get and veto on dressed leptons const vector dressedElectrons = apply(event, "elecs").dressedLeptons(); const vector dressedMuons = apply(event, "muons").dressedLeptons(); if (!dressedElectrons.empty()) vetoEvent; if (!dressedMuons.empty()) vetoEvent; // Get jets const Jets& all_jets = apply( event, "jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.5); const FastJets& ljets_fj = apply( event, "ljets"); const Jets all_ljets = ljets_fj.jetsByPt(); // Trim the large-R jets Jets trimmedJets; fastjet::Filter trimmer(fastjet::JetDefinition(fastjet::kt_algorithm, 0.2), fastjet::SelectorPtFractionMin(0.05)); for (const Jet& jet : all_ljets) trimmedJets += ljets_fj.trimJet(jet, trimmer); trimmedJets = sortByPt(trimmedJets); // Check large-R jets Jets ljets; vector b_tagged; for (const Jet& jet : trimmedJets) { if (jet.pT() < 250 * GeV) continue; if (jet.pT() > 3000 * GeV) continue; if (jet.mass() > jet.pT()) continue; if (jet.abseta() > 2.0 ) continue; ljets += jet; b_tagged += jet.bTagged(); } if (all_jets.size() < 2) vetoEvent; if (ljets.size() < 2) vetoEvent; // Identify top and anti top, compute some event variables const FourMomentum ttbar = ljets[0].momentum() + ljets[1].momentum(); const FourMomentum t1 = ljets[0].momentum(); const FourMomentum t2 = ljets[1].momentum(); const double chi = calcChi(t1, t2); const double cosThetaStar = abs(calcCosThetaStar(t1, t2)); const double pout = abs(calcPout(t1, t2)); const double dPhi = deltaPhi(t1, t2); if ( t2.pT() < 350*GeV) vetoEvent; if ( t1.pT() < 500*GeV) vetoEvent; // b-tagging for particle done on large-R jets if (!(b_tagged[0] && b_tagged[1])) vetoEvent; // Continues with signal region cuts if ( abs(t1.mass() - 172.5 * GeV) > 50*GeV ) vetoEvent; if ( abs(t2.mass() - 172.5 * GeV) > 50*GeV ) vetoEvent; _h["inclusive"]->fill(0); fillHistograms("t1_pt", t1.pT()/GeV); fillHistograms("t1_y", t1.absrap()); fillHistograms("t2_pt", t2.pT()/GeV); fillHistograms("t2_y", t2.absrap()); fillHistograms("tt_m", ttbar.mass()/TeV); fillHistograms("tt_pt", ttbar.pT()/GeV); fillHistograms("tt_Ht", (t1.pT() + t2.pT())/GeV); fillHistograms("tt_y", ttbar.absrap()); fillHistograms("tt_yboost", 0.5 * abs(t1.rapidity() + t2.rapidity())); fillHistograms("tt_chi", chi); fillHistograms("tt_cosThStar", cosThetaStar); fillHistograms("tt_pout", pout/GeV); fillHistograms("tt_dPhi", dPhi); } void finalize() { // Normalize histograms const double sf = crossSection() / sumOfWeights(); for (auto &hist : _h) { scale(hist.second, sf); if ((hist.first.find("_norm") != string::npos) && hist.second->integral(false)>0) hist.second->normalize(1.0, false); } } double calcChi(const FourMomentum& t1, const FourMomentum& t2) { double ystar = 0.5 * (t1.rapidity()-t2.rapidity()); double chi = exp( 2 * abs(ystar)); return chi; } double calcCosThetaStar(const FourMomentum& t1, const FourMomentum& t2) { FourMomentum ttbar = t1 + t2; LorentzTransform centreOfMassTrans; ttbar.setX(0); ttbar.setY(0); centreOfMassTrans.setBetaVec( -ttbar.betaVec() ); FourMomentum t1_star = centreOfMassTrans.transform(t1); double cosThetaStar = t1_star.pz()/t1_star.p3().mod(); return cosThetaStar; } double calcPout(const FourMomentum& t1, const FourMomentum& t2) { Vector3 t1V = t1.p3(); Vector3 t2V = t2.p3(); Vector3 zUnit = Vector3(0., 0., 1.); Vector3 vPerp = zUnit.cross(t1V); double pout = vPerp.dot(t2V)/vPerp.mod(); return pout; } private: map _h; //some functions for booking, filling and scaling the histograms void fillHistograms(std::string name, double value) { _h[name]->fill(value); _h[name + "_norm"]->fill(value); } void fillParton(std::string name, double value) { _h[name + "_parton"]->fill(value); _h[name + "_parton_norm"]->fill(value); } void bookHistograms(const std::string name, unsigned int index, bool onlyParton = false) { if (!onlyParton) { book(_h[name], index, 1, 1 ); book(_h[name + "_norm"], index + 13, 1, 1 ); } book(_h[name + "_parton"], index + 82, 1, 1 ); book(_h[name + "_parton_norm"], index + 97, 1, 1 ); } }; DECLARE_RIVET_PLUGIN(ATLAS_2018_I1646686); } diff --git a/docker/rivet-herwig/Dockerfile b/docker/rivet-herwig/Dockerfile new file mode 100644 --- /dev/null +++ b/docker/rivet-herwig/Dockerfile @@ -0,0 +1,26 @@ +FROM hepstore/rivet:2.6.0 +MAINTAINER Andy Buckley + +RUN dnf install -y boost-devel + +RUN mkdir /code + +RUN cd /code && \ + wget https://www.hepforge.org/archive/lhapdf/LHAPDF-6.2.1.tar.gz -O- | tar xz && \ + cd LHAPDF-*/ && ./configure --prefix=/usr/local && \ + make -j5 && make install + +RUN lhapdf install MMHT2014{,n}lo68cl + +RUN cd /code && \ + wget https://www.hepforge.org/archive/thepeg/ThePEG-2.1.3.tar.bz2 -O- | tar xj && \ + cd ThePEG-*/ && ./configure --enable-shared --{prefix,with-{fastjet,hepmc,lhapdf,rivet}}=/usr/local && \ + make -j5 && make install + +RUN cd code/ && \ + wget https://www.hepforge.org/archive/herwig/Herwig-7.1.3.tar.bz2 -O- | tar xj && \ + cd Herwig-*/ && \ + ./configure --{prefix,with-{thepeg,fastjet}}=/usr/local && \ + make -j5 && make install + +RUN rm -rf /code diff --git a/docker/rivet-pythia/Dockerfile b/docker/rivet-pythia/Dockerfile new file mode 100644 --- /dev/null +++ b/docker/rivet-pythia/Dockerfile @@ -0,0 +1,23 @@ +FROM hepstore/rivet:2.6.0 +MAINTAINER Andy Buckley + +RUN dnf install -y rsync +RUN mkdir /code + +RUN cd /code && \ + wget https://www.hepforge.org/archive/lhapdf/LHAPDF-6.2.1.tar.gz -O- | tar xz && \ + cd LHAPDF-*/ && ./configure --prefix=/usr/local && \ + make -j5 && make install + +RUN cd /code && \ + wget http://home.thep.lu.se/~torbjorn/pythia8/pythia8235.tgz -O- | tar xz && \ + cd pythia*/ && ./configure --enable-shared --{prefix,with-{hepmc2,lhapdf6}}=/usr/local && \ + make -j5 && make install + +RUN cd code/ && \ + wget https://www.hepforge.org/archive/agile/Sacrifice-1.1.1b.tar.gz -O- | tar xz && \ + cd Sacrifice-*/ && \ + ./configure --{prefix,with-{pythia,hepmc,LHAPDF}}=/usr/local && \ + make -j5 && make install + +RUN rm -rf /code diff --git a/docker/rivet-tutorial/CMS_2017_I1594909.cc b/docker/rivet-tutorial/CMS_2017_I1594909.cc new file mode 100644 --- /dev/null +++ b/docker/rivet-tutorial/CMS_2017_I1594909.cc @@ -0,0 +1,268 @@ +// -*- C++ -*- +#include "Rivet/Analysis.hh" +#include "Rivet/Projections/FinalState.hh" +#include "Rivet/Projections/FastJets.hh" +#include "Rivet/Projections/ChargedFinalState.hh" +#include "Rivet/Projections/VisibleFinalState.hh" +#include "Rivet/Projections/MissingMomentum.hh" +#include "Rivet/Projections/SmearedParticles.hh" +#include "Rivet/Projections/SmearedJets.hh" +#include "Rivet/Projections/SmearedMET.hh" +#include "Rivet/Tools/Cutflow.hh" +#include + +namespace Rivet { + + + /// CMS search for SUSY with multijet + MET signatures in 36/fb of 13 TeV pp data + class CMS_2017_I1594909 : public Analysis { + public: + + /// Constructor + DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2017_I1594909); + + + /// @name Analysis methods + //@{ + + /// Book histograms and initialise projections before the run + void init() { + + VisibleFinalState pfall; + declare(pfall, "PFAll"); + ChargedFinalState pfchg(Cuts::abseta < 2.5); + declare(pfchg, "PFChg"); + + FastJets jets(FinalState(Cuts::abseta < 4.9), FastJets::ANTIKT, 0.4); + SmearedJets recojets(jets, JET_SMEAR_CMS_RUN2, [](const Jet& j){ return j.bTagged() ? 0.55 : j.cTagged() ? 0.12 : 0.016; }); + declare(recojets, "Jets"); + + FinalState electrons(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.5); + SmearedParticles recoelectrons(electrons, ELECTRON_EFF_CMS_RUN2); + declare(recoelectrons, "Electrons"); + + FinalState muons(Cuts::abspid == PID::MUON && Cuts::abseta < 2.4); + SmearedParticles recomuons(muons, MUON_EFF_CMS_RUN2); + declare(recomuons, "Muons"); + + VisibleFinalState calofs(Cuts::abseta < 4.9 && Cuts::abspid != PID::MUON); + MissingMomentum met(calofs); + SmearedMET recomet(met, MET_SMEAR_CMS_RUN2); + declare(recomet, "MET"); + + + // Book counters, into a map of 3 indices since the global index is not obvious to calculate + size_t i = 0; + for (int j = 1; j <= 5; ++j) { + for (int b = 1; b <= 4; ++b) { + if (j == 1 && b == 4) continue; + for (int k = 1; k <= 10; ++k) { + if (j > 3 && (k == 1 || k == 4)) continue; + stringstream s; s << "count_" << (i+1); // << "_" << j << b << k; + _counts[make_tuple(j,b,k)] = bookCounter(s.str()); + i += 1; + } + } + } + MSG_DEBUG("Booked " << i << " signal regions (should be 174)"); + // Aggregate SR counters + for (size_t i = 0; i < 12; ++i) + _counts_agg[i] = bookCounter("count_agg_" + toString(i+1)); + + + // Book cut-flow + _flow = Cutflow("Presel", {"Njet>=2", "HT>300", "HTmiss>300", + "Nmuon=0", "Nmuisotrk=0", "Nelec=0", "Nelisotrk=0", "Nhadisotrk=0", + "dPhi_miss,j1>0.5", "dPhi_miss,j2>0.5", "dPhi_miss,j3>0.3", "dPhi_miss,j4>0.3" + }); + + } + + + /// Perform the per-event analysis + void analyze(const Event& event) { + + _flow.fillinit(); + + // Find leptons and isolation particles + const Particles elecs = apply(event, "Electrons").particlesByPt(); + const Particles mus = apply(event, "Muons").particlesByPt(); + const Particles pfall = apply(event, "PFAll").particlesByPt(); + const Particles pfiso = filter_select(pfall, [](const Particle& p){ return p.isHadron() || p.pid() == PID::PHOTON; }); + + // Find isolated leptons + const Particles isoleps = filter_select(elecs+mus, [&](const Particle& l){ + const double dR = l.pT() < 50*GeV ? 0.2 : l.pT() < 200*GeV ? 10*GeV/l.pT() : 0.05; + const double sumpt = sum(filter_select(pfiso, deltaRLess(l, dR)), pT, 0.0); + return sumpt/l.pT() < (l.abspid() == PID::ELECTRON ? 0.1 : 0.2); //< different I criteria for e and mu + }); + + // Find other isolated tracks + const Particles pfchg = apply(event, "PFChg").particlesByPt(); + const Particles isochgs = filter_select(pfchg, [&](const Particle& t){ + if (t.abseta() > 2.4) return false; + if (any(isoleps, deltaRLess(t, 0.01))) return false; //< don't count isolated leptons here + const double sumpt = sum(filter_select(pfchg, deltaRLess(t, 0.3)), pT, -t.pT()); + return sumpt/t.pT() < ((t.abspid() == PID::ELECTRON || t.abspid() == PID::MUON) ? 0.2 : 0.1); + }); + + // Find and isolate jets + const Jets jets = apply(event, "Jets").jetsByPt(Cuts::pT > 30*GeV); + const Jets isojets = filter_select(jets, Cuts::abseta < 2.4); //< @todo Isolation from leptons?!? + const int njets = isojets.size(); + const Jets isobjets = filter_select(isojets, hasBTag()); + const int nbjets = isobjets.size(); + MSG_DEBUG("Njets = " << jets.size() << ", Nisojets = " << njets << ", Nbjets = " << nbjets); + + // Calculate HT, HTmiss, and pTmiss quantities + const double ht = sum(jets, pT, 0.0); + const Vector3 vhtmiss = -sum(jets, pTvec, Vector3()); + const double htmiss = vhtmiss.perp(); + const Vector3& vptmiss = -apply(event, "MET").vectorEt(); + const double ptmiss = vptmiss.perp(); + MSG_DEBUG("HT = " << ht/GeV << " GeV, HTmiss = " << htmiss/GeV << " GeV"); + + + ///////////////////////////////////// + // Event selection + + // Njet cut + if (njets < 2) vetoEvent; + _flow.fill(1); + // HT cut + if (ht < 300*GeV) vetoEvent; + _flow.fill(2); + // HTmiss cut + if (htmiss < 300*GeV) vetoEvent; + _flow.fill(3); + + // // Isolated leptons cut + // if (!filter_select(isoleps, Cuts::pT > 10*GeV).empty()) vetoEvent; + // // Isolated tracks cut + // for (const Particle& t : isochgs) { + // const double mT = sqrt(2*t.pT()*ptmiss * (1 - cos(deltaPhi(t, vptmiss))) ); + // if (mT < 100*GeV) continue; + // const double pTmax = (t.abspid() == PID::ELECTRON || t.abspid() == PID::MUON) ? 5*GeV : 10*GeV; + // if (t.pT() > pTmax) vetoEvent; + // } + // + // + // Inefficiently separated version of isolation cuts for detailed cutflow debugging + // Muon cut + if (!filter_select(isoleps, Cuts::pT > 10*GeV && Cuts::abspid == PID::MUON).empty()) vetoEvent; + _flow.fill(4); + // Muon isotrk cut + for (const Particle& t : filter_select(isochgs, Cuts::abspid == PID::MUON)) { + const double mT = sqrt(2*t.pT()*ptmiss * (1 - cos(deltaPhi(t, vptmiss))) ); + if (mT > 100*GeV && t.pT() > 5*GeV) vetoEvent; + } + _flow.fill(5); + // Electron cut + if (!filter_select(isoleps, Cuts::pT > 10*GeV && Cuts::abspid == PID::ELECTRON).empty()) vetoEvent; + _flow.fill(6); + // Electron isotrk cut + for (const Particle& t : filter_select(isochgs, Cuts::abspid == PID::ELECTRON)) { + const double mT = sqrt(2*t.pT()*ptmiss * (1 - cos(deltaPhi(t, vptmiss))) ); + if (mT > 100*GeV && t.pT() > 5*GeV) vetoEvent; + } + _flow.fill(7); + // Hadron isotrk cut + for (const Particle& t : filter_select(isochgs, Cuts::abspid != PID::ELECTRON && Cuts::abspid != PID::MUON)) { + const double mT = sqrt(2*t.pT()*ptmiss * (1 - cos(deltaPhi(t, vptmiss))) ); + if (mT > 100*GeV && t.pT() > 10*GeV) vetoEvent; + } + // + // + _flow.fill(8); + + + // dPhi(jet,HTmiss) cuts + if (deltaPhi(vhtmiss, isojets[0]) < 0.5) vetoEvent; + _flow.fill(9); + if (deltaPhi(vhtmiss, isojets[1]) < 0.5) vetoEvent; + _flow.fill(10); + if (njets >= 3 && deltaPhi(vhtmiss, isojets[2]) < 0.3) vetoEvent; + _flow.fill(11); + if (njets >= 4 && deltaPhi(vhtmiss, isojets[3]) < 0.3) vetoEvent; + _flow.fill(12); + + + ///////////////////////////////////// + // Find SR index and fill counter + + const double w = event.weight(); + + const int idx_j = binIndex(njets, vector{2,3,5,7,9}, true); + const int idx_b = binIndex(nbjets, vector{0,1,2,3}, true); + int idx_k = -1; + if (inRange(htmiss/GeV, 300, 350)) { + idx_k = ht < 500*GeV ? 1 : ht < 1000*GeV ? 2 : 3; + } else if (inRange(htmiss/GeV, 350, 500) && ht > 350*GeV) { + idx_k = ht < 500*GeV ? 4 : ht < 1000*GeV ? 5 : 6; + } else if (inRange(htmiss/GeV, 500, 750) && ht > 500*GeV) { + idx_k = ht < 1000*GeV ? 7 : 8; + } else if (htmiss/GeV > 750 && ht > 750*GeV) { + idx_k = ht < 1500*GeV ? 9 : 10; + } + + // Fill via 3-tuple index + if (idx_j >= 0 && idx_b >= 0 && idx_k >= 0) { + const auto idx = make_tuple(idx_j+1,idx_b+1,idx_k); + if (has_key(_counts, idx)) _counts[idx]->fill(w); + } + + + ///////////////////////////////////// + // Aggregate SRs + + // Region Njet Nb-jet HT [GeV] HTmiss [GeV] Parton multiplicity Heavy flavor ? ∆m + if (njets >= 2 && nbjets == 0 && ht >= 500*GeV && htmiss >= 500*GeV) _counts_agg[0]->fill(w); + if (njets >= 3 && nbjets == 0 && ht >= 1500*GeV && htmiss >= 750*GeV) _counts_agg[1]->fill(w); + if (njets >= 5 && nbjets == 0 && ht >= 500*GeV && htmiss >= 500*GeV) _counts_agg[2]->fill(w); + if (njets >= 5 && nbjets == 0 && ht >= 1500*GeV && htmiss >= 750*GeV) _counts_agg[3]->fill(w); + if (njets >= 9 && nbjets == 0 && ht >= 1500*GeV && htmiss >= 750*GeV) _counts_agg[4]->fill(w); + if (njets >= 2 && nbjets >= 2 && ht >= 500*GeV && htmiss >= 500*GeV) _counts_agg[5]->fill(w); + if (njets >= 3 && nbjets >= 1 && ht >= 750*GeV && htmiss >= 750*GeV) _counts_agg[6]->fill(w); + if (njets >= 5 && nbjets >= 3 && ht >= 500*GeV && htmiss >= 500*GeV) _counts_agg[7]->fill(w); + if (njets >= 5 && nbjets >= 2 && ht >= 1500*GeV && htmiss >= 750*GeV) _counts_agg[8]->fill(w); + if (njets >= 9 && nbjets >= 3 && ht >= 750*GeV && htmiss >= 750*GeV) _counts_agg[9]->fill(w); + if (njets >= 7 && nbjets >= 1 && ht >= 300*GeV && htmiss >= 300*GeV) _counts_agg[10]->fill(w); + if (njets >= 5 && nbjets >= 1 && ht >= 750*GeV && htmiss >= 750*GeV) _counts_agg[11]->fill(w); + + } + + + /// Normalise histograms etc., after the run + void finalize() { + + const double norm = 35.9*crossSection()/femtobarn; + const double sf = norm/sumOfWeights(); + + for (auto& idx_cptr : _counts) + scale(idx_cptr.second, sf); + for (CounterPtr& cptr : _counts_agg) + scale(cptr, sf); + + _flow.scale(sf); + MSG_INFO("CUTFLOWS:\n\n" << _flow); + + } + + //@} + + + private: + + Cutflow _flow; + + map, CounterPtr> _counts; + CounterPtr _counts_agg[12]; + + }; + + + // The hook for the plugin system + DECLARE_RIVET_PLUGIN(CMS_2017_I1594909); + + +} diff --git a/docker/rivet-tutorial/Dockerfile b/docker/rivet-tutorial/Dockerfile new file mode 100644 --- /dev/null +++ b/docker/rivet-tutorial/Dockerfile @@ -0,0 +1,10 @@ +FROM hepstore/rivet-pythia +MAINTAINER Andy Buckley + +CMD /bin/bash + +WORKDIR /work + +ADD . /work + +RUN yum install -y nano diff --git a/docker/rivet-tutorial/TESTDET.cc b/docker/rivet-tutorial/TESTDET.cc new file mode 100644 --- /dev/null +++ b/docker/rivet-tutorial/TESTDET.cc @@ -0,0 +1,188 @@ +// -*- C++ -*- +#include "Rivet/Analysis.hh" +#include "Rivet/Projections/FastJets.hh" +#include "Rivet/Projections/IdentifiedFinalState.hh" +#include "Rivet/Projections/TauFinder.hh" +#include "Rivet/Projections/Smearing.hh" + +namespace Rivet { + + + class TESTDET : public Analysis { + public: + + /// Constructor + DEFAULT_RIVET_ANALYSIS_CTOR(TESTDET); + + + /// @name Analysis methods + //@{ + + /// Book histograms and initialise projections before the run + void init() { + + FinalState calofs(Cuts::abseta < 4.9); + + FastJets fj(calofs, FastJets::ANTIKT, 0.4); + declare(fj, "TrueJets"); + SmearedJets sj(fj, JET_SMEAR_ATLAS_RUN2); + declare(sj, "RecoJets"); + + MissingMomentum mm(calofs); + declare(mm, "TrueMET"); + SmearedMET sm(mm, MET_SMEAR_ATLAS_RUN2); + declare(sm, "RecoMET"); + + FinalState truthelectrons(Cuts::abseta < 2.5 && Cuts::pT > 10*GeV && Cuts::abspid == PID::ELECTRON); + declare(truthelectrons, "TrueElecs"); + SmearedParticles recoelectrons(truthelectrons, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2); + declare(recoelectrons, "RecoElecs"); + + FinalState truthmuons(Cuts::abseta < 2.7 && Cuts::pT > 10*GeV && Cuts::abspid == PID::ELECTRON); + declare(truthmuons, "TrueMuons"); + SmearedParticles recomuons(truthmuons, MUON_EFF_ATLAS_RUN1, MUON_SMEAR_ATLAS_RUN1); + declare(recomuons, "RecoMuons"); + + + _h_nj_true = bookHisto1D("jet_N_true", 10, -0.5, 9.5); + _h_nj_reco = bookHisto1D("jet_N_reco", 10, -0.5, 9.5); + _h_nbj_true = bookHisto1D("jet_Nb_true", 10, -0.5, 9.5); + _h_nbj_reco = bookHisto1D("jet_Nb_reco", 10, -0.5, 9.5); + _h_j1pt_true = bookHisto1D("jet_pt1_true", logspace(30, 1, 400)); + _h_j1pt_reco = bookHisto1D("jet_pt1_reco", logspace(30, 1, 400)); + _h_j1eta_true = bookHisto1D("jet_eta1_true", 20, -5.0, 5.0); + _h_j1eta_reco = bookHisto1D("jet_eta1_reco", 20, -5.0, 5.0); + + _h_ne_true = bookHisto1D("elec_N_true", 5, -0.5, 4.5); + _h_ne_reco = bookHisto1D("elec_N_reco", 5, -0.5, 4.5); + _h_e1pt_true = bookHisto1D("elec_pt1_true", logspace(30, 1, 400)); + _h_e1pt_reco = bookHisto1D("elec_pt1_reco", logspace(30, 1, 400)); + _h_e1eta_true = bookHisto1D("elec_eta1_true", 20, -5.0, 5.0); + _h_e1eta_reco = bookHisto1D("elec_eta1_reco", 20, -5.0, 5.0); + + _h_nm_true = bookHisto1D("muon_N_true", 5, -0.5, 4.5); + _h_nm_reco = bookHisto1D("muon_N_reco", 5, -0.5, 4.5); + _h_m1pt_true = bookHisto1D("muon_pt1_true", logspace(30, 1, 400)); + _h_m1pt_reco = bookHisto1D("muon_pt1_reco", logspace(30, 1, 400)); + _h_m1eta_true = bookHisto1D("muon_eta1_true", 20, -5.0, 5.0); + _h_m1eta_reco = bookHisto1D("muon_eta1_reco", 20, -5.0, 5.0); + + _h_met_true = bookHisto1D("met_true", logspace(30, 1, 400)); + _h_met_reco = bookHisto1D("met_reco", logspace(30, 1, 400)); + } + + + /// Perform the per-event analysis + void analyze(const Event& event) { + const double weight = event.weight(); + + const Jets tjets = apply(event, "TrueJets").jetsByPt(Cuts::pT > 40*GeV); + const Jets rjets = apply(event, "RecoJets").jetsByPt(Cuts::pT > 40*GeV); + MSG_DEBUG("Numbers of jets = " << tjets.size() << " true; " << rjets.size() << " reco"); + _h_nj_true->fill(tjets.size(), weight); + _h_nj_reco->fill(rjets.size(), weight); + const Jets tbjets = filter_select(tjets, [](const Jet& j){ return j.bTagged(Cuts::pT > 5*GeV); }); + const Jets rbjets = filter_select(rjets, [](const Jet& j){ return j.bTagged(Cuts::pT > 5*GeV); }); + MSG_DEBUG("Numbers of b-jets = " << tbjets.size() << " true; " << rbjets.size() << " reco"); + _h_nbj_true->fill(tbjets.size(), weight); + _h_nbj_reco->fill(rbjets.size(), weight); + if (!tjets.empty()) { + _h_j1pt_true->fill(tjets.front().pT()/GeV, weight); + _h_j1eta_true->fill(tjets.front().eta(), weight); + } + if (!rjets.empty()) { + _h_j1pt_reco->fill(rjets.front().pT()/GeV, weight); + _h_j1eta_reco->fill(rjets.front().eta(), weight); + } + + const Particles& telecs = apply(event, "TrueElecs").particlesByPt(20*GeV); + Particles relecs = apply(event, "RecoElecs").particlesByPt(20*GeV); + ifilter_select(relecs, particleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_TIGHT)); + MSG_DEBUG("Numbers of electrons = " << telecs.size() << " true; " << relecs.size() << " reco"); + _h_ne_true->fill(telecs.size(), weight); + _h_ne_reco->fill(relecs.size(), weight); + if (!telecs.empty()) { + _h_e1pt_true->fill(telecs.front().pT()/GeV, weight); + _h_e1eta_true->fill(telecs.front().eta(), weight); + } + if (!relecs.empty()) { + _h_e1pt_reco->fill(relecs.front().pT()/GeV, weight); + _h_e1eta_reco->fill(relecs.front().eta(), weight); + } + + const Particles& tmuons = apply(event, "TrueMuons").particlesByPt(20*GeV); + const Particles& rmuons = apply(event, "RecoMuons").particlesByPt(20*GeV); + MSG_DEBUG("Numbers of muons = " << tmuons.size() << " true; " << rmuons.size() << " reco"); + _h_nm_true->fill(tmuons.size(), weight); + _h_nm_reco->fill(rmuons.size(), weight); + if (!tmuons.empty()) { + _h_m1pt_true->fill(tmuons.front().pT()/GeV, weight); + _h_m1eta_true->fill(tmuons.front().eta(), weight); + } + if (!rmuons.empty()) { + _h_m1pt_reco->fill(rmuons.front().pT()/GeV, weight); + _h_m1eta_reco->fill(rmuons.front().eta(), weight); + } + + const double tmet = apply(event, "TrueMET").met(); + const double rmet = apply(event, "RecoMET").met(); + _h_met_true->fill(tmet/GeV, weight); + _h_met_reco->fill(rmet/GeV, weight); + + } + + + /// Normalise histograms etc., after the run + void finalize() { + + // normalize(_h_nj_true); + // normalize(_h_nj_reco); + // normalize(_h_nbj_true); + // normalize(_h_nbj_reco); + // normalize(_h_j1pt_true, 1-_h_nj_true->bin(0).area()); + // normalize(_h_j1pt_reco, 1-_h_nj_reco->bin(0).area()); + // normalize(_h_j1eta_true, 1-_h_nj_true->bin(0).area()); + // normalize(_h_j1eta_reco, 1-_h_nj_reco->bin(0).area()); + + // normalize(_h_ne_true); + // normalize(_h_ne_reco); + // normalize(_h_e1pt_true, 1-_h_ne_true->bin(0).area()); + // normalize(_h_e1pt_reco, 1-_h_ne_reco->bin(0).area()); + // normalize(_h_e1eta_true, 1-_h_ne_true->bin(0).area()); + // normalize(_h_e1eta_reco, 1-_h_ne_reco->bin(0).area()); + + // normalize(_h_nm_true); + // normalize(_h_nm_reco); + // normalize(_h_m1pt_true, 1-_h_nm_true->bin(0).area()); + // normalize(_h_m1pt_reco, 1-_h_nm_reco->bin(0).area()); + // normalize(_h_m1eta_true, 1-_h_nm_true->bin(0).area()); + // normalize(_h_m1eta_reco, 1-_h_nm_reco->bin(0).area()); + + // normalize(_h_met_true); + // normalize(_h_met_reco); + + } + + //@} + + + private: + + /// @name Histograms + //@{ + Histo1DPtr _h_nj_true, _h_nj_reco, _h_nbj_true, _h_nbj_reco, _h_ne_true, _h_ne_reco, _h_nm_true, _h_nm_reco; + Histo1DPtr _h_j1pt_true, _h_j1pt_reco, _h_e1pt_true, _h_e1pt_reco, _h_m1pt_true, _h_m1pt_reco; + Histo1DPtr _h_j1eta_true, _h_j1eta_reco, _h_e1eta_true, _h_e1eta_reco, _h_m1eta_true, _h_m1eta_reco; + Histo1DPtr _h_met_true, _h_met_reco; + //@} + + + }; + + + + // The hook for the plugin system + DECLARE_RIVET_PLUGIN(TESTDET); + + +} diff --git a/docker/rivet-tutorial/gg_g1500_chi100_g-ttchi.slha b/docker/rivet-tutorial/gg_g1500_chi100_g-ttchi.slha new file mode 100644 --- /dev/null +++ b/docker/rivet-tutorial/gg_g1500_chi100_g-ttchi.slha @@ -0,0 +1,800 @@ +##****************************************************************** +## MadGraph/MadEvent * +##****************************************************************** +## Les Houches friendly file for the (MS)SM parameters of MadGraph * +## SM parameter set and decay widths produced by MSSMCalc * +##****************************************************************** +##*Please note the following IMPORTANT issues: * +## * +##0. REFRAIN from editing this file by hand! Some of the parame- * +## ters are not independent. Always use a calculator. * +## * +##1. alpha_S(MZ) has been used in the calculation of the parameters* +## This value is KEPT by madgraph when no pdf are used lpp(i)=0, * +## but, for consistency, it will be reset by madgraph to the * +## value expected IF the pdfs for collisions with hadrons are * +## used. * +## * +##2. Values of the charm and bottom kinematic (pole) masses are * +## those used in the matrix elements and phase space UNLESS they * +## are set to ZERO from the start in the model (particles.dat) * +## This happens, for example, when using 5-flavor QCD where * +## charm and bottom are treated as partons in the initial state * +## and a zero mass might be hardwired in the model definition. * +## * +## The SUSY decays have calculated using SDECAY 1.1a * +## * +##****************************************************************** +# +BLOCK DCINFO # Decay Program information + 1 SDECAY # decay calculator + 2 1.1a # version number +# +BLOCK SPINFO # Spectrum calculator information + 1 ISASUGRA + 2 7.81 +# +BLOCK MODSEL # Model selection + 1 1 # +# +BLOCK SMINPUTS # Standard Model inputs + 1 1.25778332E+02 # alpha_em^-1(M_Z)^MSbar + 2 1.16570000E-05 # G_F [GeV^-2] + 3 1.17200002E-01 # alpha_S(M_Z)^MSbar + 4 8.93764874E+01 # M_Z pole mass + 5 4.19999981E+00 # mb(mb)^MSbar + 6 1.54540821E+02 # mt pole mass (extracted) + 7 1.94850223E+00 # mtau pole mass (extracted) +# +BLOCK MINPAR # Input parameters - minimal models + 1 6.00000000E+02 # m_0 + 2 3.00000000E+02 # m_{1/2} + 3 1.00000000E+01 # tan(beta) + 4 1.00000000E+00 # sign(mu) +# +BLOCK EXTPAR # Input parameters - non-minimal models + 0 2.21278347E+16 # Input scale +# +BLOCK MASS # Mass Spectrum +# PDG code mass particle + 5 4.81955182E+00 # b-quark pole mass (extracted) + 6 1.54540821E+02 # t-quark pole mass (not read by ME) + 24 7.71761851E+01 # W+ + 25 1.11844620E+02 # h + 35 7.49062561E+02 # H + 36 7.43967712E+02 # A + 37 7.53755432E+02 # H+ + 1000001 4.50000000E+03 # + 2000001 4.50000000E+03 # + 1000002 4.50000000E+03 # + 2000002 4.50000000E+03 # + 1000003 4.50000000E+03 # + 2000003 4.50000000E+03 # + 1000004 4.50000000E+03 # + 2000004 4.50000000E+03 # + 1000005 4.50000000E+03 # + 2000005 4.50000000E+03 # + 1000006 4.50000000E+03 # + 2000006 4.50000000E+03 # + 1000011 4.50000000E+03 # + 2000011 4.50000000E+03 # + 1000012 4.50000000E+03 # + 1000013 4.50000000E+03 # + 2000013 4.50000000E+03 # + 1000014 4.50000000E+03 # + 1000015 4.50000000E+03 # + 2000015 4.50000000E+03 # + 1000016 4.50000000E+03 # + 1000021 1500 # @ + 1000022 100 # @ + 1000023 4.50000000E+03 # + 1000025 4.50000000E+03 # + 1000035 4.50000000E+03 # + 1000024 4.50000000E+03 # + 1000037 4.50000000E+03 # +# +BLOCK NMIX # Neutralino Mixing Matrix + 1 1 1.00000000E+00 # N_11 + 1 2 0.00000000E+00 # N_12 + 1 3 0.00000000E+00 # N_13 + 1 4 0.00000000E+00 # N_14 + 2 1 0.00000000E+00 # N_21 + 2 2 1.00000000E+00 # N_22 + 2 3 0.00000000E+00 # N_23 + 2 4 0.00000000E+00 # N_24 + 3 1 0.00000000E+00 # N_31 + 3 2 0.00000000E+00 # N_32 + 3 3 1.00000000E+00 # N_33 + 3 4 0.00000000E+00 # N_34 + 4 1 0.00000000E+00 # N_41 + 4 2 0.00000000E+00 # N_42 + 4 3 0.00000000E+00 # N_43 + 4 4 1.00000000E+00 # N_44 +# +BLOCK UMIX # Chargino Mixing Matrix U + 1 1 1.00000000E+00 # U_11 + 1 2 0.00000000E+00 # U_12 + 2 1 0.00000000E+00 # U_21 + 2 2 1.00000000E+00 # U_22 +# +BLOCK VMIX # Chargino Mixing Matrix V + 1 1 1.00000000E+00 # V_11 + 1 2 0.00000000E+00 # V_12 + 2 1 0.00000000E+00 # V_21 + 2 2 1.00000000E+00 # V_22 +# +BLOCK STOPMIX # Stop Mixing Matrix + 1 1 1.00000000E+00 # O_{11} + 1 2 0.00000000E+00 # O_{12} + 2 1 0.00000000E+00 # O_{21} + 2 2 1.00000000E+00 # O_{22} +# +BLOCK SBOTMIX # Sbottom Mixing Matrix + 1 1 1.00000000E+00 # O_{11} + 1 2 0.00000000E+00 # O_{12} + 2 1 0.00000000E+00 # O_{21} + 2 2 1.00000000E+00 # O_{22} +# +BLOCK STAUMIX # Stau Mixing Matrix + 1 1 1.00000000E+00 # O_{11} + 1 2 0.00000000E+00 # O_{12} + 2 1 0.00000000E+00 # O_{21} + 2 2 1.00000000E+00 # O_{22} +# +BLOCK ALPHA # Higgs mixing + -1.02914833E-01 # Mixing angle in the neutral Higgs boson sector +# +BLOCK HMIX Q= 6.61219971E+02 # DRbar Higgs Parameters + 1 4.12454407E+02 # mu(Q) + 2 9.36003455E+00 # tanb (extracted) + 3 2.50607727E+02 # Higgs vev at Q + 4 5.53487938E+05 # m_A^2(Q) +# +BLOCK GAUGE Q= 6.61219971E+02 # The gauge couplings + 3 1.07381373E+00 # g3(Q) MSbar +# +BLOCK AU Q= 6.61219971E+02 # The trilinear couplings + 3 3 -5.32061523E+02 # A_t(Q) DRbar + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK AD Q= 6.61219971E+02 # The trilinear couplings + 3 3 -8.07902039E+02 # A_b(Q) DRbar + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK AE Q= 6.61219971E+02 # The trilinear couplings + 3 3 -1.81115051E+02 # A_tau(Q) DRbar + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK YU Q= 6.61219971E+02 # The Yukawa couplings + 3 3 8.85841429E-01 # y_t(Q) (extracted) + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK YD Q= 6.61219971E+02 # The Yukawa couplings + 3 3 1.36232540E-01 # y_b(Q) (extracted) + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK YE Q= 6.61219971E+02 # The Yukawa couplings + 3 3 1.01981103E-01 # y_tau(Q) (extracted) + 1 1 0.000000e+00 # dummy + 2 2 0.000000e+00 # dummy +# +BLOCK MSOFT Q= 6.61219971E+02 # The soft SUSY breaking masses at the scale Q + 1 1.24019547E+02 # M_1(Q) + 2 2.32185043E+02 # M_2(Q) + 3 6.86750671E+02 # M_3(Q) + 31 6.29402649E+02 # MeL(Q) + 32 6.29402649E+02 # MmuL(Q) + 33 6.26662476E+02 # MtauL(Q) + 34 6.08800842E+02 # MeR(Q) + 35 6.08800842E+02 # MmuR(Q) + 36 6.03154236E+02 # MtauR(Q) + 41 8.48326294E+02 # MqL1(Q) + 42 8.48326294E+02 # MqL2(Q) + 43 7.40788147E+02 # MqL3(Q) + 44 8.34092896E+02 # MuR(Q) + 45 8.34092896E+02 # McR(Q) + 46 5.90198242E+02 # MtR(Q) + 47 8.32408752E+02 # MdR(Q) + 48 8.32408752E+02 # MsR(Q) + 49 8.31454102E+02 # MbR(Q) +# +# +# +# ================= +# |The decay table| +# ================= +# +# - The multi-body decays for the inos, stops and sbottoms are included. +# +# - The SUSY decays of the top quark are included. +# +# +# PDG Width +DECAY 23 2.22426094E+00 # Z width (SM calculation) +DECAY 24 1.80894237E+00 # W width (SM calculation) +# +# PDG Width +DECAY 6 1.02218095E+00 # top decays +# BR NDA ID1 ID2 + 1.00000000E+00 2 5 24 # BR(t -> b W+) + 0.00000000E+00 2 5 37 # BR(t -> b H+) + 0.00000000E+00 2 1000006 1000022 # BR(t -> ~t_1 ~chi_10) + 0.00000000E+00 2 1000006 1000023 # BR(t -> ~t_1 ~chi_20) + 0.00000000E+00 2 1000006 1000025 # BR(t -> ~t_1 ~chi_30) + 0.00000000E+00 2 1000006 1000035 # BR(t -> ~t_1 ~chi_40) + 0.00000000E+00 2 2000006 1000022 # BR(t -> ~t_2 ~chi_10) + 0.00000000E+00 2 2000006 1000023 # BR(t -> ~t_2 ~chi_20) + 0.00000000E+00 2 2000006 1000025 # BR(t -> ~t_2 ~chi_30) + 0.00000000E+00 2 2000006 1000035 # BR(t -> ~t_2 ~chi_40) +# +# PDG Width +DECAY 25 1.65461618E-03 # h decays +# BR NDA ID1 ID2 + 1.47339152E-01 2 15 -15 # BR(H1 -> tau- tau+) + 7.81441418E-01 2 5 -5 # BR(H1 -> b bb) + 6.76395564E-02 2 24 -24 # BR(H1 -> W+ W-) + 3.57987415E-03 2 23 23 # BR(H1 -> Z Z) +# +# PDG Width +DECAY 35 1.26118245E+00 # H decays +# BR NDA ID1 ID2 + 1.21586159E-01 2 15 -15 # BR(H -> tau- tau+) + 2.21890882E-01 2 6 -6 # BR(H -> t tb) + 6.50784860E-01 2 5 -5 # BR(H -> b bb) + 1.26971777E-03 2 24 -24 # BR(H -> W+ W-) + 6.21230085E-04 2 23 23 # BR(H -> Z Z) + 0.00000000E+00 2 24 -37 # BR(H -> W+ H-) + 0.00000000E+00 2 -24 37 # BR(H -> W- H+) + 0.00000000E+00 2 37 -37 # BR(H -> H+ H-) + 3.84715147E-03 2 25 25 # BR(H -> h h) + 0.00000000E+00 2 36 36 # BR(H -> A A) +# +# PDG Width +DECAY 36 1.32606570E+00 # A decays +# BR NDA ID1 ID2 + 1.14768736E-01 2 15 -15 # BR(A -> tau- tau+) + 2.69728288E-01 2 6 -6 # BR(A -> t tb) + 6.14379413E-01 2 5 -5 # BR(A -> b bb) + 1.12356280E-03 2 23 25 # BR(A -> Z h) + 0.00000000E+00 2 23 35 # BR(A -> Z H) + 0.00000000E+00 2 24 -37 # BR(A -> W+ H-) + 0.00000000E+00 2 -24 37 # BR(A -> W- H+) +# +# PDG Width +DECAY 37 1.27808456E+00 # H+ decays +# BR NDA ID1 ID2 + 1.20644761E-01 2 -15 16 # BR(H+ -> tau+ nu_tau) + 8.78124903E-01 2 6 -5 # BR(H+ -> t bb) + 1.23033590E-03 2 24 25 # BR(H+ -> W+ h) + 0.00000000E+00 2 24 35 # BR(H+ -> W+ H) + 0.00000000E+00 2 24 36 # BR(H+ -> W+ A) +# +# PDG Width +DECAY 1000021 7.40992706E-02 # gluino decays +# BR NDA ID1 ID2 ID3 + 2.50000000E-01 3 1000022 6 -6 # BR(~g -> ~chi_10 t tb) +# 2.50000000E-01 3 1000022 2 -2 # BR(~g -> ~chi_10 u ub) +# 2.50000000E-01 3 1000022 3 -3 # BR(~g -> ~chi_10 s sb) +# 2.50000000E-01 3 1000022 4 -4 # BR(~g -> ~chi_10 c cb) +# +# PDG Width +DECAY 1000006 5.69449678E+00 # stop1 decays +# BR NDA ID1 ID2 + 1.88206930E-01 2 1000022 6 # BR(~t_1 -> ~chi_10 t ) + 9.44603249E-02 2 1000023 6 # BR(~t_1 -> ~chi_20 t ) + 1.70455913E-01 2 1000025 6 # BR(~t_1 -> ~chi_30 t ) + 2.29109632E-02 2 1000035 6 # BR(~t_1 -> ~chi_40 t ) + 2.42095992E-01 2 1000024 5 # BR(~t_1 -> ~chi_1+ b ) + 2.81869877E-01 2 1000037 5 # BR(~t_1 -> ~chi_2+ b ) + 0.00000000E+00 2 1000021 6 # BR(~t_1 -> ~g t ) + 0.00000000E+00 2 1000005 37 # BR(~t_1 -> ~b_1 H+) + 0.00000000E+00 2 2000005 37 # BR(~t_1 -> ~b_2 H+) + 0.00000000E+00 2 1000005 24 # BR(~t_1 -> ~b_1 W+) + 0.00000000E+00 2 2000005 24 # BR(~t_1 -> ~b_2 W+) +# +# PDG Width +DECAY 2000006 1.47683155E+01 # stop2 decays +# BR NDA ID1 ID2 + 1.04775334E-02 2 1000022 6 # BR(~t_2 -> ~chi_10 t ) + 1.13972560E-01 2 1000023 6 # BR(~t_2 -> ~chi_20 t ) + 1.57562942E-01 2 1000025 6 # BR(~t_2 -> ~chi_30 t ) + 2.57314086E-01 2 1000035 6 # BR(~t_2 -> ~chi_40 t ) + 2.40022120E-01 2 1000024 5 # BR(~t_2 -> ~chi_1+ b ) + 1.04238005E-01 2 1000037 5 # BR(~t_2 -> ~chi_2+ b ) + 0.00000000E+00 2 1000021 6 # BR(~t_2 -> ~g t ) + 4.81590640E-02 2 1000006 25 # BR(~t_2 -> ~t_1 h ) + 0.00000000E+00 2 1000006 35 # BR(~t_2 -> ~t_1 H ) + 0.00000000E+00 2 1000006 36 # BR(~t_2 -> ~t_1 A ) + 0.00000000E+00 2 1000005 37 # BR(~t_2 -> ~b_1 H+) + 0.00000000E+00 2 2000005 37 # BR(~t_2 -> ~b_2 H+) + 6.82536895E-02 2 1000006 23 # BR(~t_2 -> ~t_1 Z ) + 0.00000000E+00 2 1000005 24 # BR(~t_2 -> ~b_1 W+) + 0.00000000E+00 2 2000005 24 # BR(~t_2 -> ~b_2 W+) +# +# PDG Width +DECAY 1000005 1.37684102E+01 # sbottom1 decays +# BR NDA ID1 ID2 + 1.24979039E-02 2 1000022 5 # BR(~b_1 -> ~chi_10 b ) + 1.62963740E-01 2 1000023 5 # BR(~b_1 -> ~chi_20 b ) + 5.39620118E-03 2 1000025 5 # BR(~b_1 -> ~chi_30 b ) + 1.32454160E-02 2 1000035 5 # BR(~b_1 -> ~chi_40 b ) + 2.97894492E-01 2 -1000024 6 # BR(~b_1 -> ~chi_1- t ) + 3.94674666E-01 2 -1000037 6 # BR(~b_1 -> ~chi_2- t ) + 1.30886580E-02 2 1000021 5 # BR(~b_1 -> ~g b ) + 0.00000000E+00 2 1000006 -37 # BR(~b_1 -> ~t_1 H-) + 0.00000000E+00 2 2000006 -37 # BR(~b_1 -> ~t_2 H-) + 1.00238923E-01 2 1000006 -24 # BR(~b_1 -> ~t_1 W-) + 0.00000000E+00 2 2000006 -24 # BR(~b_1 -> ~t_2 W-) +# +# PDG Width +DECAY 2000005 4.02050211E+00 # sbottom2 decays +# BR NDA ID1 ID2 + 1.16939193E-01 2 1000022 5 # BR(~b_2 -> ~chi_10 b ) + 9.67521720E-04 2 1000023 5 # BR(~b_2 -> ~chi_20 b ) + 2.44620085E-02 2 1000025 5 # BR(~b_2 -> ~chi_30 b ) + 2.54122057E-02 2 1000035 5 # BR(~b_2 -> ~chi_40 b ) + 9.99862983E-04 2 -1000024 6 # BR(~b_2 -> ~chi_1- t ) + 6.61498667E-02 2 -1000037 6 # BR(~b_2 -> ~chi_2- t ) + 7.55931029E-01 2 1000021 5 # BR(~b_2 -> ~g b ) + 0.00000000E+00 2 1000005 25 # BR(~b_2 -> ~b_1 h ) + 0.00000000E+00 2 1000005 35 # BR(~b_2 -> ~b_1 H ) + 0.00000000E+00 2 1000005 36 # BR(~b_2 -> ~b_1 A ) + 0.00000000E+00 2 1000006 -37 # BR(~b_2 -> ~t_1 H-) + 0.00000000E+00 2 2000006 -37 # BR(~b_2 -> ~t_2 H-) + 0.00000000E+00 2 1000005 23 # BR(~b_2 -> ~b_1 Z ) + 9.13831226E-03 2 1000006 -24 # BR(~b_2 -> ~t_1 W-) + 0.00000000E+00 2 2000006 -24 # BR(~b_2 -> ~t_2 W-) +# +# PDG Width +DECAY 1000002 1.31301150E+01 # sup_L decays +# BR NDA ID1 ID2 + 5.97240819E-03 2 1000022 2 # BR(~u_L -> ~chi_10 u) + 2.13814900E-01 2 1000023 2 # BR(~u_L -> ~chi_20 u) + 6.54997799E-04 2 1000025 2 # BR(~u_L -> ~chi_30 u) + 1.15708854E-02 2 1000035 2 # BR(~u_L -> ~chi_40 u) + 4.34593064E-01 2 1000024 1 # BR(~u_L -> ~chi_1+ d) + 1.55107464E-02 2 1000037 1 # BR(~u_L -> ~chi_2+ d) + 3.17882998E-01 2 1000021 2 # BR(~u_L -> ~g u) +# +# PDG Width +DECAY 2000002 5.45626401E+00 # sup_R decays +# BR NDA ID1 ID2 + 3.56050387E-01 2 1000022 2 # BR(~u_R -> ~chi_10 u) + 1.95018645E-03 2 1000023 2 # BR(~u_R -> ~chi_20 u) + 5.79103054E-04 2 1000025 2 # BR(~u_R -> ~chi_30 u) + 2.22793094E-03 2 1000035 2 # BR(~u_R -> ~chi_40 u) + 0.00000000E+00 2 1000024 1 # BR(~u_R -> ~chi_1+ d) + 0.00000000E+00 2 1000037 1 # BR(~u_R -> ~chi_2+ d) + 6.39192393E-01 2 1000021 2 # BR(~u_R -> ~g u) +# +# PDG Width +DECAY 1000001 1.31836627E+01 # sdown_L decays +# BR NDA ID1 ID2 + 1.36015082E-02 2 1000022 1 # BR(~d_L -> ~chi_10 d) + 2.00968062E-01 2 1000023 1 # BR(~d_L -> ~chi_20 d) + 1.12614606E-03 2 1000025 1 # BR(~d_L -> ~chi_30 d) + 1.52229825E-02 2 1000035 1 # BR(~d_L -> ~chi_40 d) + 3.97020140E-01 2 -1000024 2 # BR(~d_L -> ~chi_1- u) + 4.05217275E-02 2 -1000037 2 # BR(~d_L -> ~chi_2- u) + 3.31539434E-01 2 1000021 1 # BR(~d_L -> ~g d) +# +# PDG Width +DECAY 2000001 3.95203891E+00 # sdown_R decays +# BR NDA ID1 ID2 + 1.22809923E-01 2 1000022 1 # BR(~d_R -> ~chi_10 d) + 6.72575606E-04 2 1000023 1 # BR(~d_R -> ~chi_20 d) + 1.99604669E-04 2 1000025 1 # BR(~d_R -> ~chi_30 d) + 7.67849884E-04 2 1000035 1 # BR(~d_R -> ~chi_40 d) + 0.00000000E+00 2 -1000024 2 # BR(~d_R -> ~chi_1- u) + 0.00000000E+00 2 -1000037 2 # BR(~d_R -> ~chi_2- u) + 8.75550047E-01 2 1000021 1 # BR(~d_R -> ~g d) +# +# PDG Width +DECAY 1000004 1.31301150E+01 # scharm_L decays +# BR NDA ID1 ID2 + 5.97240819E-03 2 1000022 4 # BR(~c_L -> ~chi_10 c) + 2.13814900E-01 2 1000023 4 # BR(~c_L -> ~chi_20 c) + 6.54997799E-04 2 1000025 4 # BR(~c_L -> ~chi_30 c) + 1.15708854E-02 2 1000035 4 # BR(~c_L -> ~chi_40 c) + 4.34593064E-01 2 1000024 3 # BR(~c_L -> ~chi_1+ s) + 1.55107464E-02 2 1000037 3 # BR(~c_L -> ~chi_2+ s) + 3.17882998E-01 2 1000021 4 # BR(~c_L -> ~g c) +# +# PDG Width +DECAY 2000004 5.45626401E+00 # scharm_R decays +# BR NDA ID1 ID2 + 3.56050387E-01 2 1000022 4 # BR(~c_R -> ~chi_10 c) + 1.95018645E-03 2 1000023 4 # BR(~c_R -> ~chi_20 c) + 5.79103054E-04 2 1000025 4 # BR(~c_R -> ~chi_30 c) + 2.22793094E-03 2 1000035 4 # BR(~c_R -> ~chi_40 c) + 0.00000000E+00 2 1000024 3 # BR(~c_R -> ~chi_1+ s) + 0.00000000E+00 2 1000037 3 # BR(~c_R -> ~chi_2+ s) + 6.39192393E-01 2 1000021 4 # BR(~c_R -> ~g c) +# +# PDG Width +DECAY 1000003 1.31836627E+01 # sstrange_L decays +# BR NDA ID1 ID2 + 1.36015082E-02 2 1000022 3 # BR(~s_L -> ~chi_10 s) + 2.00968062E-01 2 1000023 3 # BR(~s_L -> ~chi_20 s) + 1.12614606E-03 2 1000025 3 # BR(~s_L -> ~chi_30 s) + 1.52229825E-02 2 1000035 3 # BR(~s_L -> ~chi_40 s) + 3.97020140E-01 2 -1000024 4 # BR(~s_L -> ~chi_1- c) + 4.05217275E-02 2 -1000037 4 # BR(~s_L -> ~chi_2- c) + 3.31539434E-01 2 1000021 3 # BR(~s_L -> ~g s) +# +# PDG Width +DECAY 2000003 3.95203891E+00 # sstrange_R decays +# BR NDA ID1 ID2 + 1.22809923E-01 2 1000022 3 # BR(~s_R -> ~chi_10 s) + 6.72575606E-04 2 1000023 3 # BR(~s_R -> ~chi_20 s) + 1.99604669E-04 2 1000025 3 # BR(~s_R -> ~chi_30 s) + 7.67849884E-04 2 1000035 3 # BR(~s_R -> ~chi_40 s) + 0.00000000E+00 2 -1000024 4 # BR(~s_R -> ~chi_1- c) + 0.00000000E+00 2 -1000037 4 # BR(~s_R -> ~chi_2- c) + 8.75550047E-01 2 1000021 3 # BR(~s_R -> ~g s) +# +# PDG Width +DECAY 1000011 6.01545605E+00 # selectron_L decays +# BR NDA ID1 ID2 + 1.11040636E-01 2 1000022 11 # BR(~e_L -> ~chi_10 e-) + 3.10532538E-01 2 1000023 11 # BR(~e_L -> ~chi_20 e-) + 2.58296815E-04 2 1000025 11 # BR(~e_L -> ~chi_30 e-) + 6.35788612E-03 2 1000035 11 # BR(~e_L -> ~chi_40 e-) + 5.41499312E-01 2 -1000024 12 # BR(~e_L -> ~chi_1- nu_e) + 3.03113305E-02 2 -1000037 12 # BR(~e_L -> ~chi_2- nu_e) +# +# PDG Width +DECAY 2000011 2.97447234E+00 # selectron_R decays +# BR NDA ID1 ID2 + 9.91606160E-01 2 1000022 11 # BR(~e_R -> ~chi_10 e-) + 4.85044533E-03 2 1000023 11 # BR(~e_R -> ~chi_20 e-) + 7.98993760E-04 2 1000025 11 # BR(~e_R -> ~chi_30 e-) + 2.74440052E-03 2 1000035 11 # BR(~e_R -> ~chi_40 e-) + 0.00000000E+00 2 -1000024 12 # BR(~e_R -> ~chi_1- nu_e) + 0.00000000E+00 2 -1000037 12 # BR(~e_R -> ~chi_2- nu_e) +# +# PDG Width +DECAY 1000013 6.01545605E+00 # smuon_L decays +# BR NDA ID1 ID2 + 1.11040636E-01 2 1000022 13 # BR(~mu_L -> ~chi_10 mu-) + 3.10532538E-01 2 1000023 13 # BR(~mu_L -> ~chi_20 mu-) + 2.58296815E-04 2 1000025 13 # BR(~mu_L -> ~chi_30 mu-) + 6.35788612E-03 2 1000035 13 # BR(~mu_L -> ~chi_40 mu-) + 5.41499312E-01 2 -1000024 14 # BR(~mu_L -> ~chi_1- nu_mu) + 3.03113305E-02 2 -1000037 14 # BR(~mu_L -> ~chi_2- nu_mu) +# +# PDG Width +DECAY 2000013 2.97447234E+00 # smuon_R decays +# BR NDA ID1 ID2 + 9.91606160E-01 2 1000022 13 # BR(~mu_R -> ~chi_10 mu-) + 4.85044533E-03 2 1000023 13 # BR(~mu_R -> ~chi_20 mu-) + 7.98993760E-04 2 1000025 13 # BR(~mu_R -> ~chi_30 mu-) + 2.74440052E-03 2 1000035 13 # BR(~mu_R -> ~chi_40 mu-) + 0.00000000E+00 2 -1000024 14 # BR(~mu_R -> ~chi_1- nu_mu) + 0.00000000E+00 2 -1000037 14 # BR(~mu_R -> ~chi_2- nu_mu) +# +# PDG Width +DECAY 1000015 3.25037203E+00 # stau_1 decays +# BR NDA ID1 ID2 + 8.62776265E-01 2 1000022 15 # BR(~tau_1 -> ~chi_10 tau-) + 4.80319526E-02 2 1000023 15 # BR(~tau_1 -> ~chi_20 tau-) + 4.21977606E-03 2 1000025 15 # BR(~tau_1 -> ~chi_30 tau-) + 2.46374419E-03 2 1000035 15 # BR(~tau_1 -> ~chi_40 tau-) + 8.12723418E-02 2 -1000024 16 # BR(~tau_1 -> ~chi_1- nu_tau) + 1.23592003E-03 2 -1000037 16 # BR(~tau_1 -> ~chi_2- nu_tau) + 0.00000000E+00 2 1000016 -37 # BR(~tau_1 -> ~nu_tauL H-) + 0.00000000E+00 2 1000016 -24 # BR(~tau_1 -> ~nu_tauL W-) +# +# PDG Width +DECAY 2000015 5.77940856E+00 # stau_2 decays +# BR NDA ID1 ID2 + 1.34953765E-01 2 1000022 15 # BR(~tau_2 -> ~chi_10 tau-) + 2.97886887E-01 2 1000023 15 # BR(~tau_2 -> ~chi_20 tau-) + 4.73358093E-03 2 1000025 15 # BR(~tau_2 -> ~chi_30 tau-) + 1.18373086E-02 2 1000035 15 # BR(~tau_2 -> ~chi_40 tau-) + 5.14907193E-01 2 -1000024 16 # BR(~tau_2 -> ~chi_1- nu_tau) + 3.56812658E-02 2 -1000037 16 # BR(~tau_2 -> ~chi_2- nu_tau) + 0.00000000E+00 2 1000016 -37 # BR(~tau_2 -> ~nu_tauL H-) + 0.00000000E+00 2 1000016 -24 # BR(~tau_2 -> ~nu_tauL W-) + 0.00000000E+00 2 1000015 25 # BR(~tau_2 -> ~tau_1 h) + 0.00000000E+00 2 1000015 35 # BR(~tau_2 -> ~tau_1 H) + 0.00000000E+00 2 1000015 36 # BR(~tau_2 -> ~tau_1 A) + 0.00000000E+00 2 1000015 23 # BR(~tau_2 -> ~tau_1 Z) +# +# PDG Width +DECAY 1000012 6.07250223E+00 # snu_eL decays +# BR NDA ID1 ID2 + 1.42806354E-01 2 1000022 12 # BR(~nu_eL -> ~chi_10 nu_e) + 2.51079690E-01 2 1000023 12 # BR(~nu_eL -> ~chi_20 nu_e) + 1.34732524E-03 2 1000025 12 # BR(~nu_eL -> ~chi_30 nu_e) + 1.36914726E-02 2 1000035 12 # BR(~nu_eL -> ~chi_40 nu_e) + 5.79974054E-01 2 1000024 11 # BR(~nu_eL -> ~chi_1+ e-) + 1.11011047E-02 2 1000037 11 # BR(~nu_eL -> ~chi_2+ e-) +# +# PDG Width +DECAY 1000014 6.07250223E+00 # snu_muL decays +# BR NDA ID1 ID2 + 1.42806354E-01 2 1000022 14 # BR(~nu_muL -> ~chi_10 nu_mu) + 2.51079690E-01 2 1000023 14 # BR(~nu_muL -> ~chi_20 nu_mu) + 1.34732524E-03 2 1000025 14 # BR(~nu_muL -> ~chi_30 nu_mu) + 1.36914726E-02 2 1000035 14 # BR(~nu_muL -> ~chi_40 nu_mu) + 5.79974054E-01 2 1000024 13 # BR(~nu_muL -> ~chi_1+ mu-) + 1.11011047E-02 2 1000037 13 # BR(~nu_muL -> ~chi_2+ mu-) +# +# PDG Width +DECAY 1000016 6.07063864E+00 # snu_tauL decays +# BR NDA ID1 ID2 + 1.42115898E-01 2 1000022 16 # BR(~nu_tauL -> ~chi_10 nu_tau) + 2.49372798E-01 2 1000023 16 # BR(~nu_tauL -> ~chi_20 nu_tau) + 1.32244004E-03 2 1000025 16 # BR(~nu_tauL -> ~chi_30 nu_tau) + 1.34038264E-02 2 1000035 16 # BR(~nu_tauL -> ~chi_40 nu_tau) + 5.77998382E-01 2 1000024 15 # BR(~nu_tauL -> ~chi_1+ tau-) + 1.57866549E-02 2 1000037 15 # BR(~nu_tauL -> ~chi_2+ tau-) + 0.00000000E+00 2 -1000015 -37 # BR(~nu_tauL -> ~tau_1+ H-) + 0.00000000E+00 2 -2000015 -37 # BR(~nu_tauL -> ~tau_2+ H-) + 0.00000000E+00 2 -1000015 -24 # BR(~nu_tauL -> ~tau_1+ W-) + 0.00000000E+00 2 -2000015 -24 # BR(~nu_tauL -> ~tau_2+ W-) +# +# PDG Width +DECAY 1000024 7.00367294E-03 # chargino1+ decays +# BR NDA ID1 ID2 + 0.00000000E+00 2 1000002 -1 # BR(~chi_1+ -> ~u_L db) + 0.00000000E+00 2 2000002 -1 # BR(~chi_1+ -> ~u_R db) + 0.00000000E+00 2 -1000001 2 # BR(~chi_1+ -> ~d_L* u ) + 0.00000000E+00 2 -2000001 2 # BR(~chi_1+ -> ~d_R* u ) + 0.00000000E+00 2 1000004 -3 # BR(~chi_1+ -> ~c_L sb) + 0.00000000E+00 2 2000004 -3 # BR(~chi_1+ -> ~c_R sb) + 0.00000000E+00 2 -1000003 4 # BR(~chi_1+ -> ~s_L* c ) + 0.00000000E+00 2 -2000003 4 # BR(~chi_1+ -> ~s_R* c ) + 0.00000000E+00 2 1000006 -5 # BR(~chi_1+ -> ~t_1 bb) + 0.00000000E+00 2 2000006 -5 # BR(~chi_1+ -> ~t_2 bb) + 0.00000000E+00 2 -1000005 6 # BR(~chi_1+ -> ~b_1* t ) + 0.00000000E+00 2 -2000005 6 # BR(~chi_1+ -> ~b_2* t ) + 0.00000000E+00 2 1000012 -11 # BR(~chi_1+ -> ~nu_eL e+ ) + 0.00000000E+00 2 1000014 -13 # BR(~chi_1+ -> ~nu_muL mu+ ) + 0.00000000E+00 2 1000016 -15 # BR(~chi_1+ -> ~nu_tau1 tau+) + 0.00000000E+00 2 -1000011 12 # BR(~chi_1+ -> ~e_L+ nu_e) + 0.00000000E+00 2 -2000011 12 # BR(~chi_1+ -> ~e_R+ nu_e) + 0.00000000E+00 2 -1000013 14 # BR(~chi_1+ -> ~mu_L+ nu_mu) + 0.00000000E+00 2 -2000013 14 # BR(~chi_1+ -> ~mu_R+ nu_mu) + 0.00000000E+00 2 -1000015 16 # BR(~chi_1+ -> ~tau_1+ nu_tau) + 0.00000000E+00 2 -2000015 16 # BR(~chi_1+ -> ~tau_2+ nu_tau) + 1.00000000E+00 2 1000022 24 # BR(~chi_1+ -> ~chi_10 W+) + 0.00000000E+00 2 1000023 24 # BR(~chi_1+ -> ~chi_20 W+) + 0.00000000E+00 2 1000025 24 # BR(~chi_1+ -> ~chi_30 W+) + 0.00000000E+00 2 1000035 24 # BR(~chi_1+ -> ~chi_40 W+) + 0.00000000E+00 2 1000022 37 # BR(~chi_1+ -> ~chi_10 H+) + 0.00000000E+00 2 1000023 37 # BR(~chi_1+ -> ~chi_20 H+) + 0.00000000E+00 2 1000025 37 # BR(~chi_1+ -> ~chi_30 H+) + 0.00000000E+00 2 1000035 37 # BR(~chi_1+ -> ~chi_40 H+) +# +# PDG Width +DECAY 1000037 2.23350902E+00 # chargino2+ decays +# BR NDA ID1 ID2 + 0.00000000E+00 2 1000002 -1 # BR(~chi_2+ -> ~u_L db) + 0.00000000E+00 2 2000002 -1 # BR(~chi_2+ -> ~u_R db) + 0.00000000E+00 2 -1000001 2 # BR(~chi_2+ -> ~d_L* u ) + 0.00000000E+00 2 -2000001 2 # BR(~chi_2+ -> ~d_R* u ) + 0.00000000E+00 2 1000004 -3 # BR(~chi_2+ -> ~c_L sb) + 0.00000000E+00 2 2000004 -3 # BR(~chi_2+ -> ~c_R sb) + 0.00000000E+00 2 -1000003 4 # BR(~chi_2+ -> ~s_L* c ) + 0.00000000E+00 2 -2000003 4 # BR(~chi_2+ -> ~s_R* c ) + 0.00000000E+00 2 1000006 -5 # BR(~chi_2+ -> ~t_1 bb) + 0.00000000E+00 2 2000006 -5 # BR(~chi_2+ -> ~t_2 bb) + 0.00000000E+00 2 -1000005 6 # BR(~chi_2+ -> ~b_1* t ) + 0.00000000E+00 2 -2000005 6 # BR(~chi_2+ -> ~b_2* t ) + 0.00000000E+00 2 1000012 -11 # BR(~chi_2+ -> ~nu_eL e+ ) + 0.00000000E+00 2 1000014 -13 # BR(~chi_2+ -> ~nu_muL mu+ ) + 0.00000000E+00 2 1000016 -15 # BR(~chi_2+ -> ~nu_tau1 tau+) + 0.00000000E+00 2 -1000011 12 # BR(~chi_2+ -> ~e_L+ nu_e) + 0.00000000E+00 2 -2000011 12 # BR(~chi_2+ -> ~e_R+ nu_e) + 0.00000000E+00 2 -1000013 14 # BR(~chi_2+ -> ~mu_L+ nu_mu) + 0.00000000E+00 2 -2000013 14 # BR(~chi_2+ -> ~mu_R+ nu_mu) + 0.00000000E+00 2 -1000015 16 # BR(~chi_2+ -> ~tau_1+ nu_tau) + 0.00000000E+00 2 -2000015 16 # BR(~chi_2+ -> ~tau_2+ nu_tau) + 3.13898343E-01 2 1000024 23 # BR(~chi_2+ -> ~chi_1+ Z ) + 9.42923324E-02 2 1000022 24 # BR(~chi_2+ -> ~chi_10 W+) + 3.63297283E-01 2 1000023 24 # BR(~chi_2+ -> ~chi_20 W+) + 0.00000000E+00 2 1000025 24 # BR(~chi_2+ -> ~chi_30 W+) + 0.00000000E+00 2 1000035 24 # BR(~chi_2+ -> ~chi_40 W+) + 2.28512042E-01 2 1000024 25 # BR(~chi_2+ -> ~chi_1+ h ) + 0.00000000E+00 2 1000024 35 # BR(~chi_2+ -> ~chi_1+ H ) + 0.00000000E+00 2 1000024 36 # BR(~chi_2+ -> ~chi_1+ A ) + 0.00000000E+00 2 1000022 37 # BR(~chi_2+ -> ~chi_10 H+) + 0.00000000E+00 2 1000023 37 # BR(~chi_2+ -> ~chi_20 H+) + 0.00000000E+00 2 1000025 37 # BR(~chi_2+ -> ~chi_30 H+) + 0.00000000E+00 2 1000035 37 # BR(~chi_2+ -> ~chi_40 H+) +# +# PDG Width +DECAY 1000022 0.00000000E+00 # neutralino1 decays +# +# PDG Width +DECAY 1000023 9.37327589E-04 # neutralino2 decays +# BR NDA ID1 ID2 + 1.00000000E+00 2 1000022 23 # BR(~chi_20 -> ~chi_10 Z ) + 0.00000000E+00 2 1000024 -24 # BR(~chi_20 -> ~chi_1+ W-) + 0.00000000E+00 2 -1000024 24 # BR(~chi_20 -> ~chi_1- W+) + 0.00000000E+00 2 1000037 -24 # BR(~chi_20 -> ~chi_2+ W-) + 0.00000000E+00 2 -1000037 24 # BR(~chi_20 -> ~chi_2- W+) + 0.00000000E+00 2 1000022 25 # BR(~chi_20 -> ~chi_10 h ) + 0.00000000E+00 2 1000022 35 # BR(~chi_20 -> ~chi_10 H ) + 0.00000000E+00 2 1000022 36 # BR(~chi_20 -> ~chi_10 A ) + 0.00000000E+00 2 1000024 -37 # BR(~chi_20 -> ~chi_1+ H-) + 0.00000000E+00 2 -1000024 37 # BR(~chi_20 -> ~chi_1- H+) + 0.00000000E+00 2 1000037 -37 # BR(~chi_20 -> ~chi_2+ H-) + 0.00000000E+00 2 -1000037 37 # BR(~chi_20 -> ~chi_2- H+) + 0.00000000E+00 2 1000002 -2 # BR(~chi_20 -> ~u_L ub) + 0.00000000E+00 2 -1000002 2 # BR(~chi_20 -> ~u_L* u ) + 0.00000000E+00 2 2000002 -2 # BR(~chi_20 -> ~u_R ub) + 0.00000000E+00 2 -2000002 2 # BR(~chi_20 -> ~u_R* u ) + 0.00000000E+00 2 1000001 -1 # BR(~chi_20 -> ~d_L db) + 0.00000000E+00 2 -1000001 1 # BR(~chi_20 -> ~d_L* d ) + 0.00000000E+00 2 2000001 -1 # BR(~chi_20 -> ~d_R db) + 0.00000000E+00 2 -2000001 1 # BR(~chi_20 -> ~d_R* d ) + 0.00000000E+00 2 1000004 -4 # BR(~chi_20 -> ~c_L cb) + 0.00000000E+00 2 -1000004 4 # BR(~chi_20 -> ~c_L* c ) + 0.00000000E+00 2 2000004 -4 # BR(~chi_20 -> ~c_R cb) + 0.00000000E+00 2 -2000004 4 # BR(~chi_20 -> ~c_R* c ) + 0.00000000E+00 2 1000003 -3 # BR(~chi_20 -> ~s_L sb) + 0.00000000E+00 2 -1000003 3 # BR(~chi_20 -> ~s_L* s ) + 0.00000000E+00 2 2000003 -3 # BR(~chi_20 -> ~s_R sb) + 0.00000000E+00 2 -2000003 3 # BR(~chi_20 -> ~s_R* s ) + 0.00000000E+00 2 1000006 -6 # BR(~chi_20 -> ~t_1 tb) + 0.00000000E+00 2 -1000006 6 # BR(~chi_20 -> ~t_1* t ) + 0.00000000E+00 2 2000006 -6 # BR(~chi_20 -> ~t_2 tb) + 0.00000000E+00 2 -2000006 6 # BR(~chi_20 -> ~t_2* t ) + 0.00000000E+00 2 1000005 -5 # BR(~chi_20 -> ~b_1 bb) + 0.00000000E+00 2 -1000005 5 # BR(~chi_20 -> ~b_1* b ) + 0.00000000E+00 2 2000005 -5 # BR(~chi_20 -> ~b_2 bb) + 0.00000000E+00 2 -2000005 5 # BR(~chi_20 -> ~b_2* b ) + 0.00000000E+00 2 1000011 -11 # BR(~chi_20 -> ~e_L- e+) + 0.00000000E+00 2 -1000011 11 # BR(~chi_20 -> ~e_L+ e-) + 0.00000000E+00 2 2000011 -11 # BR(~chi_20 -> ~e_R- e+) + 0.00000000E+00 2 -2000011 11 # BR(~chi_20 -> ~e_R+ e-) + 0.00000000E+00 2 1000013 -13 # BR(~chi_20 -> ~mu_L- mu+) + 0.00000000E+00 2 -1000013 13 # BR(~chi_20 -> ~mu_L+ mu-) + 0.00000000E+00 2 2000013 -13 # BR(~chi_20 -> ~mu_R- mu+) + 0.00000000E+00 2 -2000013 13 # BR(~chi_20 -> ~mu_R+ mu-) + 0.00000000E+00 2 1000015 -15 # BR(~chi_20 -> ~tau_1- tau+) + 0.00000000E+00 2 -1000015 15 # BR(~chi_20 -> ~tau_1+ tau-) + 0.00000000E+00 2 2000015 -15 # BR(~chi_20 -> ~tau_2- tau+) + 0.00000000E+00 2 -2000015 15 # BR(~chi_20 -> ~tau_2+ tau-) + 0.00000000E+00 2 1000012 -12 # BR(~chi_20 -> ~nu_eL nu_eb) + 0.00000000E+00 2 -1000012 12 # BR(~chi_20 -> ~nu_eL* nu_e ) + 0.00000000E+00 2 1000014 -14 # BR(~chi_20 -> ~nu_muL nu_mub) + 0.00000000E+00 2 -1000014 14 # BR(~chi_20 -> ~nu_muL* nu_mu ) + 0.00000000E+00 2 1000016 -16 # BR(~chi_20 -> ~nu_tau1 nu_taub) + 0.00000000E+00 2 -1000016 16 # BR(~chi_20 -> ~nu_tau1* nu_tau ) +# +# PDG Width +DECAY 1000025 2.16222723E+00 # neutralino3 decays +# BR NDA ID1 ID2 + 1.12205625E-01 2 1000022 23 # BR(~chi_30 -> ~chi_10 Z ) + 2.42360898E-01 2 1000023 23 # BR(~chi_30 -> ~chi_20 Z ) + 3.06499253E-01 2 1000024 -24 # BR(~chi_30 -> ~chi_1+ W-) + 3.06499253E-01 2 -1000024 24 # BR(~chi_30 -> ~chi_1- W+) + 0.00000000E+00 2 1000037 -24 # BR(~chi_30 -> ~chi_2+ W-) + 0.00000000E+00 2 -1000037 24 # BR(~chi_30 -> ~chi_2- W+) + 2.16639745E-02 2 1000022 25 # BR(~chi_30 -> ~chi_10 h ) + 0.00000000E+00 2 1000022 35 # BR(~chi_30 -> ~chi_10 H ) + 0.00000000E+00 2 1000022 36 # BR(~chi_30 -> ~chi_10 A ) + 1.07709952E-02 2 1000023 25 # BR(~chi_30 -> ~chi_20 h ) + 0.00000000E+00 2 1000023 35 # BR(~chi_30 -> ~chi_20 H ) + 0.00000000E+00 2 1000023 36 # BR(~chi_30 -> ~chi_20 A ) + 0.00000000E+00 2 1000024 -37 # BR(~chi_30 -> ~chi_1+ H-) + 0.00000000E+00 2 -1000024 37 # BR(~chi_30 -> ~chi_1- H+) + 0.00000000E+00 2 1000037 -37 # BR(~chi_30 -> ~chi_2+ H-) + 0.00000000E+00 2 -1000037 37 # BR(~chi_30 -> ~chi_2- H+) + 0.00000000E+00 2 1000002 -2 # BR(~chi_30 -> ~u_L ub) + 0.00000000E+00 2 -1000002 2 # BR(~chi_30 -> ~u_L* u ) + 0.00000000E+00 2 2000002 -2 # BR(~chi_30 -> ~u_R ub) + 0.00000000E+00 2 -2000002 2 # BR(~chi_30 -> ~u_R* u ) + 0.00000000E+00 2 1000001 -1 # BR(~chi_30 -> ~d_L db) + 0.00000000E+00 2 -1000001 1 # BR(~chi_30 -> ~d_L* d ) + 0.00000000E+00 2 2000001 -1 # BR(~chi_30 -> ~d_R db) + 0.00000000E+00 2 -2000001 1 # BR(~chi_30 -> ~d_R* d ) + 0.00000000E+00 2 1000004 -4 # BR(~chi_30 -> ~c_L cb) + 0.00000000E+00 2 -1000004 4 # BR(~chi_30 -> ~c_L* c ) + 0.00000000E+00 2 2000004 -4 # BR(~chi_30 -> ~c_R cb) + 0.00000000E+00 2 -2000004 4 # BR(~chi_30 -> ~c_R* c ) + 0.00000000E+00 2 1000003 -3 # BR(~chi_30 -> ~s_L sb) + 0.00000000E+00 2 -1000003 3 # BR(~chi_30 -> ~s_L* s ) + 0.00000000E+00 2 2000003 -3 # BR(~chi_30 -> ~s_R sb) + 0.00000000E+00 2 -2000003 3 # BR(~chi_30 -> ~s_R* s ) + 0.00000000E+00 2 1000006 -6 # BR(~chi_30 -> ~t_1 tb) + 0.00000000E+00 2 -1000006 6 # BR(~chi_30 -> ~t_1* t ) + 0.00000000E+00 2 2000006 -6 # BR(~chi_30 -> ~t_2 tb) + 0.00000000E+00 2 -2000006 6 # BR(~chi_30 -> ~t_2* t ) + 0.00000000E+00 2 1000005 -5 # BR(~chi_30 -> ~b_1 bb) + 0.00000000E+00 2 -1000005 5 # BR(~chi_30 -> ~b_1* b ) + 0.00000000E+00 2 2000005 -5 # BR(~chi_30 -> ~b_2 bb) + 0.00000000E+00 2 -2000005 5 # BR(~chi_30 -> ~b_2* b ) + 0.00000000E+00 2 1000011 -11 # BR(~chi_30 -> ~e_L- e+) + 0.00000000E+00 2 -1000011 11 # BR(~chi_30 -> ~e_L+ e-) + 0.00000000E+00 2 2000011 -11 # BR(~chi_30 -> ~e_R- e+) + 0.00000000E+00 2 -2000011 11 # BR(~chi_30 -> ~e_R+ e-) + 0.00000000E+00 2 1000013 -13 # BR(~chi_30 -> ~mu_L- mu+) + 0.00000000E+00 2 -1000013 13 # BR(~chi_30 -> ~mu_L+ mu-) + 0.00000000E+00 2 2000013 -13 # BR(~chi_30 -> ~mu_R- mu+) + 0.00000000E+00 2 -2000013 13 # BR(~chi_30 -> ~mu_R+ mu-) + 0.00000000E+00 2 1000015 -15 # BR(~chi_30 -> ~tau_1- tau+) + 0.00000000E+00 2 -1000015 15 # BR(~chi_30 -> ~tau_1+ tau-) + 0.00000000E+00 2 2000015 -15 # BR(~chi_30 -> ~tau_2- tau+) + 0.00000000E+00 2 -2000015 15 # BR(~chi_30 -> ~tau_2+ tau-) + 0.00000000E+00 2 1000012 -12 # BR(~chi_30 -> ~nu_eL nu_eb) + 0.00000000E+00 2 -1000012 12 # BR(~chi_30 -> ~nu_eL* nu_e ) + 0.00000000E+00 2 1000014 -14 # BR(~chi_30 -> ~nu_muL nu_mub) + 0.00000000E+00 2 -1000014 14 # BR(~chi_30 -> ~nu_muL* nu_mu ) + 0.00000000E+00 2 1000016 -16 # BR(~chi_30 -> ~nu_tau1 nu_taub) + 0.00000000E+00 2 -1000016 16 # BR(~chi_30 -> ~nu_tau1* nu_tau ) +# +# PDG Width +DECAY 1000035 2.37932556E+00 # neutralino4 decays +# BR NDA ID1 ID2 + 2.36489274E-02 2 1000022 23 # BR(~chi_40 -> ~chi_10 Z ) + 1.94410793E-02 2 1000023 23 # BR(~chi_40 -> ~chi_20 Z ) + 0.00000000E+00 2 1000025 23 # BR(~chi_40 -> ~chi_30 Z ) + 3.39474740E-01 2 1000024 -24 # BR(~chi_40 -> ~chi_1+ W-) + 3.39474740E-01 2 -1000024 24 # BR(~chi_40 -> ~chi_1- W+) + 0.00000000E+00 2 1000037 -24 # BR(~chi_40 -> ~chi_2+ W-) + 0.00000000E+00 2 -1000037 24 # BR(~chi_40 -> ~chi_2- W+) + 9.26914543E-02 2 1000022 25 # BR(~chi_40 -> ~chi_10 h ) + 0.00000000E+00 2 1000022 35 # BR(~chi_40 -> ~chi_10 H ) + 0.00000000E+00 2 1000022 36 # BR(~chi_40 -> ~chi_10 A ) + 1.85269058E-01 2 1000023 25 # BR(~chi_40 -> ~chi_20 h ) + 0.00000000E+00 2 1000023 35 # BR(~chi_40 -> ~chi_20 H ) + 0.00000000E+00 2 1000023 36 # BR(~chi_40 -> ~chi_20 A ) + 0.00000000E+00 2 1000025 25 # BR(~chi_40 -> ~chi_30 h ) + 0.00000000E+00 2 1000025 35 # BR(~chi_40 -> ~chi_30 H ) + 0.00000000E+00 2 1000025 36 # BR(~chi_40 -> ~chi_30 A ) + 0.00000000E+00 2 1000024 -37 # BR(~chi_40 -> ~chi_1+ H-) + 0.00000000E+00 2 -1000024 37 # BR(~chi_40 -> ~chi_1- H+) + 0.00000000E+00 2 1000037 -37 # BR(~chi_40 -> ~chi_2+ H-) + 0.00000000E+00 2 -1000037 37 # BR(~chi_40 -> ~chi_2- H+) + 0.00000000E+00 2 1000002 -2 # BR(~chi_40 -> ~u_L ub) + 0.00000000E+00 2 -1000002 2 # BR(~chi_40 -> ~u_L* u ) + 0.00000000E+00 2 2000002 -2 # BR(~chi_40 -> ~u_R ub) + 0.00000000E+00 2 -2000002 2 # BR(~chi_40 -> ~u_R* u ) + 0.00000000E+00 2 1000001 -1 # BR(~chi_40 -> ~d_L db) + 0.00000000E+00 2 -1000001 1 # BR(~chi_40 -> ~d_L* d ) + 0.00000000E+00 2 2000001 -1 # BR(~chi_40 -> ~d_R db) + 0.00000000E+00 2 -2000001 1 # BR(~chi_40 -> ~d_R* d ) + 0.00000000E+00 2 1000004 -4 # BR(~chi_40 -> ~c_L cb) + 0.00000000E+00 2 -1000004 4 # BR(~chi_40 -> ~c_L* c ) + 0.00000000E+00 2 2000004 -4 # BR(~chi_40 -> ~c_R cb) + 0.00000000E+00 2 -2000004 4 # BR(~chi_40 -> ~c_R* c ) + 0.00000000E+00 2 1000003 -3 # BR(~chi_40 -> ~s_L sb) + 0.00000000E+00 2 -1000003 3 # BR(~chi_40 -> ~s_L* s ) + 0.00000000E+00 2 2000003 -3 # BR(~chi_40 -> ~s_R sb) + 0.00000000E+00 2 -2000003 3 # BR(~chi_40 -> ~s_R* s ) + 0.00000000E+00 2 1000006 -6 # BR(~chi_40 -> ~t_1 tb) + 0.00000000E+00 2 -1000006 6 # BR(~chi_40 -> ~t_1* t ) + 0.00000000E+00 2 2000006 -6 # BR(~chi_40 -> ~t_2 tb) + 0.00000000E+00 2 -2000006 6 # BR(~chi_40 -> ~t_2* t ) + 0.00000000E+00 2 1000005 -5 # BR(~chi_40 -> ~b_1 bb) + 0.00000000E+00 2 -1000005 5 # BR(~chi_40 -> ~b_1* b ) + 0.00000000E+00 2 2000005 -5 # BR(~chi_40 -> ~b_2 bb) + 0.00000000E+00 2 -2000005 5 # BR(~chi_40 -> ~b_2* b ) + 0.00000000E+00 2 1000011 -11 # BR(~chi_40 -> ~e_L- e+) + 0.00000000E+00 2 -1000011 11 # BR(~chi_40 -> ~e_L+ e-) + 0.00000000E+00 2 2000011 -11 # BR(~chi_40 -> ~e_R- e+) + 0.00000000E+00 2 -2000011 11 # BR(~chi_40 -> ~e_R+ e-) + 0.00000000E+00 2 1000013 -13 # BR(~chi_40 -> ~mu_L- mu+) + 0.00000000E+00 2 -1000013 13 # BR(~chi_40 -> ~mu_L+ mu-) + 0.00000000E+00 2 2000013 -13 # BR(~chi_40 -> ~mu_R- mu+) + 0.00000000E+00 2 -2000013 13 # BR(~chi_40 -> ~mu_R+ mu-) + 0.00000000E+00 2 1000015 -15 # BR(~chi_40 -> ~tau_1- tau+) + 0.00000000E+00 2 -1000015 15 # BR(~chi_40 -> ~tau_1+ tau-) + 0.00000000E+00 2 2000015 -15 # BR(~chi_40 -> ~tau_2- tau+) + 0.00000000E+00 2 -2000015 15 # BR(~chi_40 -> ~tau_2+ tau-) + 0.00000000E+00 2 1000012 -12 # BR(~chi_40 -> ~nu_eL nu_eb) + 0.00000000E+00 2 -1000012 12 # BR(~chi_40 -> ~nu_eL* nu_e ) + 0.00000000E+00 2 1000014 -14 # BR(~chi_40 -> ~nu_muL nu_mub) + 0.00000000E+00 2 -1000014 14 # BR(~chi_40 -> ~nu_muL* nu_mu ) + 0.00000000E+00 2 1000016 -16 # BR(~chi_40 -> ~nu_tau1 nu_taub) + 0.00000000E+00 2 -1000016 16 # BR(~chi_40 -> ~nu_tau1* nu_tau ) diff --git a/docker/rivet-tutorial/truerecosplit.sh b/docker/rivet-tutorial/truerecosplit.sh new file mode 100644 --- /dev/null +++ b/docker/rivet-tutorial/truerecosplit.sh @@ -0,0 +1,5 @@ +OUTTRUE=${1/.yoda/-true.yoda} +yoda2yoda -m ".*_true" $1 - | sed -e s/_true// > $OUTTRUE + +OUTRECO=${1/.yoda/-reco.yoda} +yoda2yoda -m ".*_reco" $1 - | sed -e s/_reco// > $OUTRECO diff --git a/src/Core/Particle.cc b/src/Core/Particle.cc --- a/src/Core/Particle.cc +++ b/src/Core/Particle.cc @@ -1,318 +1,318 @@ #include "Rivet/Particle.hh" #include "Rivet/Tools/Cuts.hh" #include "Rivet/Tools/ParticleIdUtils.hh" #include "Rivet/Tools/ParticleUtils.hh" namespace Rivet { void Particle::setConstituents(const Particles& cs, bool setmom) { _constituents = cs; if (setmom) _momentum = sum(cs, p4, FourMomentum()); } void Particle::addConstituent(const Particle& c, bool addmom) { _constituents += c; if (addmom) _momentum += c; } void Particle::addConstituents(const Particles& cs, bool addmom) { _constituents += cs; if (addmom) for (const Particle& c : cs) _momentum += c; } Particles Particle::rawConstituents() const { if (!isComposite()) return Particles{*this}; Particles rtn; for (const Particle& p : constituents()) rtn += p.rawConstituents(); return rtn; } Particle& Particle::transformBy(const LorentzTransform& lt) { _momentum = lt.transform(_momentum); return *this; } bool Particle::isVisible() const { // Charged particles are visible if ( PID::charge3(pid()) != 0 ) return true; // Neutral hadrons are visible if ( PID::isHadron(pid()) ) return true; // Photons are visible if ( pid() == PID::PHOTON ) return true; // Gluons are visible (for parton level analyses) if ( pid() == PID::GLUON ) return true; // Everything else is invisible return false; } bool Particle::isStable() const { return genParticle() != NULL && genParticle()->status() == 1 && genParticle()->end_vertex() == NULL; } Particles Particle::ancestors(const Cut& c, bool physical_only) const { Particles rtn; // this case needed protecting against (at least for the latest Herwig... not sure why // it didn't show up earlier if (genParticle() == NULL) return rtn; /// @todo Remove this const mess crap when HepMC doesn't suck GenVertexPtr gv = const_cast( genParticle()->production_vertex() ); if (gv == NULL) return rtn; /// @todo Would like to do this, but the range objects are broken // for (const GenParticlePtr gp, gv->particles(HepMC::children)) // rtn += Particle(gp); for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::ancestors); it != gv->particles_end(HepMC::ancestors); ++it) { if (physical_only && (*it)->status() != 1 && (*it)->status() != 2) continue; const Particle p(*it); if (c != Cuts::OPEN && !c->accept(p)) continue; rtn += p; } return rtn; } Particles Particle::parents(const Cut& c) const { Particles rtn; /// @todo Remove this const mess crap when HepMC doesn't suck GenVertexPtr gv = const_cast( genParticle()->production_vertex() ); if (gv == NULL) return rtn; /// @todo Would like to do this, but the range objects are broken // for (const GenParticlePtr gp, gv->particles(HepMC::children)) // rtn += Particle(gp); for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::parents); it != gv->particles_end(HepMC::parents); ++it) { const Particle p(*it); if (c != Cuts::OPEN && !c->accept(p)) continue; rtn += p; } return rtn; } Particles Particle::children(const Cut& c) const { Particles rtn; /// @todo Something going wrong with taus -> GenParticle nullptr? if (genParticle() == nullptr) return rtn; if (isStable()) return rtn; /// @todo Remove this const mess crap when HepMC doesn't suck - cout << genParticle()->end_vertex() << endl; + //cout << genParticle()->end_vertex() << endl; GenVertexPtr gv = const_cast( genParticle()->end_vertex() ); if (gv == nullptr) return rtn; /// @todo Would like to do this, but the range objects are broken // for (const GenParticlePtr gp, gv->particles(HepMC::children)) // rtn += Particle(gp); for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::children); it != gv->particles_end(HepMC::children); ++it) { const Particle p(*it); if (c != Cuts::OPEN && !c->accept(p)) continue; rtn += p; } return rtn; } /// @todo Insist that the current particle is post-hadronization, otherwise throw an exception? /// @todo Use recursion through replica-avoiding functions to avoid bookkeeping duplicates Particles Particle::allDescendants(const Cut& c, bool remove_duplicates) const { Particles rtn; if (isStable()) return rtn; /// @todo Remove this const mess crap when HepMC doesn't suck GenVertexPtr gv = const_cast( genParticle()->end_vertex() ); if (gv == NULL) return rtn; /// @todo Would like to do this, but the range objects are broken // for (const GenParticlePtr gp, gv->particles(HepMC::descendants)) for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it) { const Particle p(*it); if (c != Cuts::OPEN && !c->accept(p)) continue; if (remove_duplicates && (*it)->end_vertex() != NULL) { // size_t n = 0; ///< @todo Only remove 1-to-1 duplicates? bool dup = false; /// @todo Yuck, HepMC for (GenVertex::particle_iterator it2 = (*it)->end_vertex()->particles_begin(HepMC::children); it2 != (*it)->end_vertex()->particles_end(HepMC::children); ++it2) { // n += 1; if (n > 1) break; if ((*it)->pdg_id() == (*it2)->pdg_id()) { dup = true; break; } } if (dup) continue; } rtn += p; } return rtn; } /// @todo Insist that the current particle is post-hadronization, otherwise throw an exception? Particles Particle::stableDescendants(const Cut& c) const { Particles rtn; if (isStable()) return rtn; /// @todo Remove this const mess crap when HepMC doesn't suck GenVertexPtr gv = const_cast( genParticle()->end_vertex() ); if (gv == NULL) return rtn; /// @todo Would like to do this, but the range objects are broken // for (const GenParticlePtr gp, gv->particles(HepMC::descendants)) for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it) { // if ((*it)->status() != 1 || (*it)->end_vertex() != NULL) continue; const Particle p(*it); if (!p.isStable()) continue; if (c != Cuts::OPEN && !c->accept(p)) continue; rtn += p; } return rtn; } double Particle::flightLength() const { if (isStable()) return -1; if (genParticle() == NULL) return 0; if (genParticle()->production_vertex() == NULL) return 0; const HepMC::FourVector v1 = genParticle()->production_vertex()->position(); const HepMC::FourVector v2 = genParticle()->end_vertex()->position(); return sqrt(sqr(v2.x()-v1.x()) + sqr(v2.y()-v1.y()) + sqr(v2.z()-v1.z())); } bool Particle::hasParent(PdgId pid) const { return hasParentWith(hasPID(pid)); } bool Particle::hasParentWith(const Cut& c) const { return hasParentWith([&](const Particle& p){return c->accept(p);}); } bool Particle::hasAncestor(PdgId pid, bool only_physical) const { return hasAncestorWith(hasPID(pid), only_physical); } bool Particle::hasAncestorWith(const Cut& c, bool only_physical) const { return hasAncestorWith([&](const Particle& p){return c->accept(p);}, only_physical); } bool Particle::hasChildWith(const Cut& c) const { return hasChildWith([&](const Particle& p){return c->accept(p);}); } bool Particle::hasDescendantWith(const Cut& c, bool remove_duplicates) const { return hasDescendantWith([&](const Particle& p){return c->accept(p);}, remove_duplicates); } bool Particle::hasStableDescendantWith(const Cut& c) const { return hasStableDescendantWith([&](const Particle& p){return c->accept(p);}); } bool Particle::fromBottom() const { return hasAncestorWith([](const Particle& p){ return p.genParticle()->status() == 2 && p.isHadron() && p.hasBottom(); }); } bool Particle::fromCharm() const { return hasAncestorWith([](const Particle& p){ return p.genParticle()->status() == 2 && p.isHadron() && p.hasCharm(); }); } bool Particle::fromHadron() const { return hasAncestorWith([](const Particle& p){ return p.genParticle()->status() == 2 && p.isHadron(); }); } bool Particle::fromTau(bool prompt_taus_only) const { if (prompt_taus_only && fromHadron()) return false; return hasAncestorWith([](const Particle& p){ return p.genParticle()->status() == 2 && isTau(p); }); } bool Particle::fromHadronicTau(bool prompt_taus_only) const { return hasAncestorWith([&](const Particle& p){ return p.genParticle()->status() == 2 && isTau(p) && (!prompt_taus_only || p.isPrompt()) && hasHadronicDecay(p); }); } bool Particle::isDirect(bool allow_from_direct_tau, bool allow_from_direct_mu) const { if (genParticle() == NULL) return false; // no HepMC connection, give up! Throw UserError exception? const GenVertexPtr prodVtx = genParticle()->production_vertex(); if (prodVtx == NULL) return false; // orphaned particle, has to be assume false const pair beams = prodVtx->parent_event()->beam_particles(); /// @todo Would be nicer to be able to write this recursively up the chain, exiting as soon as a parton or string/cluster is seen for (const GenParticlePtr ancestor : Rivet::particles(prodVtx, HepMC::ancestors)) { const PdgId pid = ancestor->pdg_id(); if (ancestor->status() != 2) continue; // no non-standard statuses or beams to be used in decision making if (ancestor == beams.first || ancestor == beams.second) continue; // PYTHIA6 uses status 2 for beams, I think... (sigh) if (PID::isParton(pid)) continue; // PYTHIA6 also uses status 2 for some partons, I think... (sigh) if (PID::isHadron(pid)) return false; // direct particles can't be from hadron decays if (abs(pid) == PID::TAU && abspid() != PID::TAU && !allow_from_direct_tau) return false; // allow or ban particles from tau decays (permitting tau copies) if (abs(pid) == PID::MUON && abspid() != PID::MUON && !allow_from_direct_mu) return false; // allow or ban particles from muon decays (permitting muon copies) } return true; } /////////////////////// // DISABLED UNTIL VANILLA CC7 COMPATIBILITY NOT NEEDED // /// Particles copy constructor from vector // Particles::Particles(const std::vector& vps) : base(vps) {} // /// Particles -> FourMomenta cast/conversion operator // Particles::operator FourMomenta () const { // // FourMomenta rtn(this->begin(), this->end()); // FourMomenta rtn; rtn.reserve(this->size()); // for (size_t i = 0; i < this->size(); ++i) rtn.push_back((*this)[i]); // return rtn; // } // /// Particles concatenation operator // Particles operator + (const Particles& a, const Particles& b) { // Particles rtn(a); // rtn += b; // return rtn; // } ////////////////////////////////// /// Allow a Particle to be passed to an ostream. std::ostream& operator << (std::ostream& os, const Particle& p) { string pname; try { pname = PID::toParticleName(p.pid()); } catch (...) { pname = "PID=" + to_str(p.pid()); } os << "Particle<" << pname << " @ " << p.momentum()/GeV << " GeV>"; return os; } /// Allow ParticlePair to be passed to an ostream. std::ostream& operator << (std::ostream& os, const ParticlePair& pp) { os << "[" << pp.first << ", " << pp.second << "]"; return os; } } diff --git a/src/Projections/FastJets.cc b/src/Projections/FastJets.cc --- a/src/Projections/FastJets.cc +++ b/src/Projections/FastJets.cc @@ -1,214 +1,215 @@ // -*- C++ -*- #include "Rivet/Config/RivetCommon.hh" #include "Rivet/Tools/Logging.hh" #include "Rivet/Projections/FastJets.hh" #include "Rivet/Projections/HeavyHadrons.hh" #include "Rivet/Projections/TauFinder.hh" namespace Rivet { void FastJets::_initBase() { setName("FastJets"); declare(HeavyHadrons(), "HFHadrons"); declare(TauFinder(TauFinder::DecayMode::HADRONIC), "Taus"); } void FastJets::_initJdef(Algo alg, double rparameter, double seed_threshold) { MSG_DEBUG("JetAlg = " << static_cast(alg)); MSG_DEBUG("R parameter = " << rparameter); MSG_DEBUG("Seed threshold = " << seed_threshold); if (alg == KT) { _jdef = fastjet::JetDefinition(fastjet::kt_algorithm, rparameter, fastjet::E_scheme); } else if (alg == CAM) { _jdef = fastjet::JetDefinition(fastjet::cambridge_algorithm, rparameter, fastjet::E_scheme); } else if (alg == ANTIKT) { _jdef = fastjet::JetDefinition(fastjet::antikt_algorithm, rparameter, fastjet::E_scheme); } else if (alg == DURHAM) { _jdef = fastjet::JetDefinition(fastjet::ee_kt_algorithm, fastjet::E_scheme); } else if (alg == GENKTEE) { _jdef = fastjet::JetDefinition(fastjet::ee_genkt_algorithm, rparameter, -1); } else { // Plugins: if (alg == SISCONE) { const double OVERLAP_THRESHOLD = 0.75; _plugin.reset(new fastjet::SISConePlugin(rparameter, OVERLAP_THRESHOLD)); // } else if (alg == PXCONE) { // string msg = "PxCone currently not supported, since FastJet doesn't install it by default. "; // msg += "Please notify the Rivet authors if this behaviour should be changed."; // throw Error(msg); // _plugin.reset(new fastjet::PxConePlugin(rparameter)); } else if (alg == ATLASCONE) { const double OVERLAP_THRESHOLD = 0.5; _plugin.reset(new fastjet::ATLASConePlugin(rparameter, seed_threshold, OVERLAP_THRESHOLD)); } else if (alg == CMSCONE) { _plugin.reset(new fastjet::CMSIterativeConePlugin(rparameter, seed_threshold)); } else if (alg == CDFJETCLU) { const double OVERLAP_THRESHOLD = 0.75; _plugin.reset(new fastjet::CDFJetCluPlugin(rparameter, OVERLAP_THRESHOLD, seed_threshold)); } else if (alg == CDFMIDPOINT) { const double OVERLAP_THRESHOLD = 0.5; _plugin.reset(new fastjet::CDFMidPointPlugin(rparameter, OVERLAP_THRESHOLD, seed_threshold)); } else if (alg == D0ILCONE) { const double min_jet_Et = 6.0; _plugin.reset(new fastjet::D0RunIIConePlugin(rparameter, min_jet_Et)); } else if (alg == JADE) { _plugin.reset(new fastjet::JadePlugin()); } else if (alg == TRACKJET) { _plugin.reset(new fastjet::TrackJetPlugin(rparameter)); } _jdef = fastjet::JetDefinition(_plugin.get()); } } CmpState FastJets::compare(const Projection& p) const { const FastJets& other = dynamic_cast(p); return \ cmp(_useMuons, other._useMuons) || cmp(_useInvisibles, other._useInvisibles) || mkNamedPCmp(other, "FS") || cmp(_jdef.jet_algorithm(), other._jdef.jet_algorithm()) || cmp(_jdef.recombination_scheme(), other._jdef.recombination_scheme()) || cmp(_jdef.plugin(), other._jdef.plugin()) || cmp(_jdef.R(), other._jdef.R()) || cmp(_adef, other._adef); } // STATIC PseudoJets FastJets::mkClusterInputs(const Particles& fsparticles, const Particles& tagparticles) { PseudoJets pjs; /// @todo Use FastJet3's UserInfo system to store Particle pointers directly? // Store 4 vector data about each particle into FastJet's PseudoJets for (size_t i = 0; i < fsparticles.size(); ++i) { fastjet::PseudoJet pj = fsparticles[i]; pj.set_user_index(i+1); pjs.push_back(pj); } // And the same for ghost tagging particles (with negative user indices) for (size_t i = 0; i < tagparticles.size(); ++i) { fastjet::PseudoJet pj = tagparticles[i]; pj *= 1e-20; ///< Ghostify the momentum pj.set_user_index(-i-1); pjs.push_back(pj); } return pjs; } // STATIC Jet FastJets::mkJet(const PseudoJet& pj, const Particles& fsparticles, const Particles& tagparticles) { const PseudoJets pjconstituents = pj.constituents(); Particles constituents, tags; constituents.reserve(pjconstituents.size()); for (const fastjet::PseudoJet& pjc : pjconstituents) { // Pure ghosts don't have corresponding particles if (pjc.has_area() && pjc.is_pure_ghost()) continue; // Default user index = 0 doesn't give valid particle lookup if (pjc.user_index() == 0) continue; // Split by index sign into constituent & tag lookup if (pjc.user_index() > 0) { // Find constituents if index > 0 const size_t i = pjc.user_index() - 1; if (i >= fsparticles.size()) throw RangeError("FS particle lookup failed in jet construction"); constituents.push_back(fsparticles.at(i)); } else if (!tagparticles.empty()) { // Find tags if index < 0 const size_t i = abs(pjc.user_index()) - 1; if (i >= tagparticles.size()) throw RangeError("Tag particle lookup failed in jet construction"); tags.push_back(tagparticles.at(i)); } } return Jet(pj, constituents, tags); } // STATIC Jets FastJets::mkJets(const PseudoJets& pjs, const Particles& fsparticles, const Particles& tagparticles) { Jets rtn; rtn.reserve(pjs.size()); for (const PseudoJet pj : pjs) { rtn.push_back(FastJets::mkJet(pj, fsparticles, tagparticles)); } return rtn; } void FastJets::project(const Event& e) { // Assemble final state particles const string fskey = (_useInvisibles == JetAlg::Invisibles::NONE) ? "VFS" : "FS"; Particles fsparticles = applyProjection(e, fskey).particles(); // Remove prompt invisibles if needed (already done by VFS if using NO_INVISIBLES) if (_useInvisibles == JetAlg::Invisibles::DECAY) { ifilter_discard(fsparticles, [](const Particle& p) { return !(p.isVisible() || p.fromDecay()); }); } // Remove prompt/all muons if needed if (_useMuons == JetAlg::Muons::DECAY) { ifilter_discard(fsparticles, [](const Particle& p) { return isMuon(p) && !p.fromDecay(); }); } else if (_useMuons == JetAlg::Muons::NONE) { ifilter_discard(fsparticles, isMuon); } // Tagging particles const Particles chadrons = applyProjection(e, "HFHadrons").cHadrons(); const Particles bhadrons = applyProjection(e, "HFHadrons").bHadrons(); const Particles taus = applyProjection(e, "Taus").particles(); calc(fsparticles, chadrons+bhadrons+taus); } void FastJets::calc(const Particles& fsparticles, const Particles& tagparticles) { MSG_DEBUG("Finding jets from " << fsparticles.size() << " input particles + " << tagparticles.size() << " tagging particles"); _fsparticles = fsparticles; _tagparticles = tagparticles; // Make pseudojets, with mapping info to Rivet FS and tag particles PseudoJets pjs = mkClusterInputs(_fsparticles, _tagparticles); // Run either basic or area-calculating cluster sequence as reqd. if (_adef) { _cseq.reset(new fastjet::ClusterSequenceArea(pjs, _jdef, *_adef)); } else { _cseq.reset(new fastjet::ClusterSequence(pjs, _jdef)); } MSG_DEBUG("ClusterSequence constructed; Njets_tot = " << _cseq->inclusive_jets().size() << ", Njets(pT > 10 GeV) = " << _cseq->inclusive_jets(10*GeV).size()); } void FastJets::reset() { _yscales.clear(); _fsparticles.clear(); _tagparticles.clear(); /// @todo _cseq = fastjet::ClusterSequence(); } Jets FastJets::_jets() const { /// @todo Cache? return mkJets(pseudojets(), _fsparticles, _tagparticles); } + /// @todo "Automate" trimming as part of project() with pre-registered Filters Jet FastJets::trimJet(const Jet& input, const fastjet::Filter& trimmer) const { if (input.pseudojet().associated_cluster_sequence() != clusterSeq().get()) throw Error("To trim a Rivet::Jet, its associated PseudoJet must have come from this FastJets' ClusterSequence"); PseudoJet pj = trimmer(input); return mkJet(pj, _fsparticles, _tagparticles); } PseudoJets FastJets::pseudoJets(double ptmin) const { return clusterSeq() ? clusterSeq()->inclusive_jets(ptmin) : PseudoJets(); } }