- Update to pythia8140
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Jul 2010 10:39:47 +0000 (10:39 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Jul 2010 10:39:47 +0000 (10:39 +0000)
- Make  independent of TPythia8 for grid tests.

200 files changed:
PYTHIA8/AliDecayerPythia8.cxx
PYTHIA8/AliDecayerPythia8.h
PYTHIA8/AliPythia8.cxx
PYTHIA8/AliPythia8.h
PYTHIA8/AliPythia8LinkDef.h
PYTHIA8/AliTPythia8.cxx [new file with mode: 0644]
PYTHIA8/AliTPythia8.h [new file with mode: 0644]
PYTHIA8/libAliPythia8.pkg
PYTHIA8/libpythia8.pkg
PYTHIA8/pythia8.C
PYTHIA8/pythia8140/include/Analysis.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/Basics.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/BeamParticle.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/BeamRemnants.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/BeamShape.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/BoseEinstein.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/Event.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/FragmentationFlavZpT.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/FragmentationSystems.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/HadronLevel.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/HepMCInterface.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/Info.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/LHAFortran.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/LHAPDFInterface.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/LesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/MiniStringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/MultipleInteractions.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ParticleData.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ParticleDecays.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PartonDistributions.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PartonLevel.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PartonSystems.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PhaseSpace.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ProcessContainer.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ProcessLevel.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/Pythia.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PythiaComplex.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/PythiaStdlib.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ResonanceDecays.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/ResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/Settings.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaCompositeness.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaEW.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaExtraDim.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaGeneric.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaHiggs.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaLeftRightSym.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaLeptoquark.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaNewGaugeBosons.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaOnia.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaProcess.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaQCD.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaSUSY.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SigmaTotal.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SpaceShower.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/StandardModel.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/StringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SusyCouplings.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/SusyLesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/TimeShower.h [new file with mode: 0644]
PYTHIA8/pythia8140/include/UserHooks.h [new file with mode: 0644]
PYTHIA8/pythia8140/src/Analysis.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/Basics.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/BeamParticle.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/BeamRemnants.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/BeamShape.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/BoseEinstein.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/Event.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/FragmentationFlavZpT.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/FragmentationSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/HadronLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/Info.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/LesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/MiniStringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/MultipleInteractions.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ParticleData.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ParticleDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/PartonDistributions.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/PartonLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/PartonSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/PhaseSpace.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ProcessContainer.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ProcessLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/Pythia.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/PythiaStdlib.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ResonanceDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/ResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/Settings.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaCompositeness.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaEW.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaExtraDim.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaGeneric.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaHiggs.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaLeftRightSym.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaLeptoquark.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaNewGaugeBosons.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaOnia.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaProcess.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaQCD.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaSUSY.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SigmaTotal.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SpaceShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/StandardModel.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/StringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SusyCouplings.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/SusyLesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/TimeShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/src/UserHooks.cxx [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ASecondHardProcess.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/AccessPYTHIA6Processes.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/AdvancedUsage.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/BeamParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/BeamRemnants.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/BeamShape.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Bibliography.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/BoseEinsteinEffects.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/CompositenessProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/CouplingsAndScales.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Diffraction.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ElectroweakProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ErrorChecks.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/EventAnalysis.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/EventInformation.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/EventRecord.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/EventStatistics.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ExternalDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ExtraDimensionalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/FlavourSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/FourVectors.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/FourthGenerationProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Fragmentation.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Frontpage.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Glossary.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/HadronLevelStandalone.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/HepMCInterface.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/HiddenValleyProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/HiggsProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Histograms.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ImplementNewShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Index.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/JetFinders.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/LeftRightSymmetryProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/LeptoquarkProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/LesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/MainProgramSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/MasterSwitches.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/MultipleInteractions.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/NewGaugeBosonProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/OniaProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/PDFSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/PYTHIA6TranslationTable.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ParticleData.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ParticleDataScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ParticleDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ParticleProperties.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/PartonDistributions.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/PhaseSpaceCuts.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ProcessSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ProgramClasses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ProgramFiles.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ProgramFlow.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ProgramMethods.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/QCDProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ROOTusage.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/RandomNumberSeed.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/RandomNumbers.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ResonanceDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SUSYLesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SUSYProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SampleMainPrograms.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SaveSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SemiInternalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SemiInternalResonances.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SettingsScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/SpacelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/StandardModelParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/TimelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/TopProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/TotalCrossSections.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Tunes.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/UpdateHistory.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/UserHooks.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Version.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/Welcome.xml [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ct09mc1.pds [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ct09mc2.pds [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ct09mcs.pds [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/cteq6l.tbl [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/cteq6l1.tbl [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/ctq66.00.pds [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/mrstlostar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/mrstlostarstar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/mstw2008lo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/mstw2008nlo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1FitA.data [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1FitB.data [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1FitBlo.data [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1JetsCharm.data [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1JetsGluon.data [new file with mode: 0644]
PYTHIA8/pythia8140/xmldoc/pomH1JetsSinglet.data [new file with mode: 0644]

index 2f9a437..86599d8 100644 (file)
@@ -19,7 +19,8 @@
 // Author: andreas.morsch@cern.ch
 #include <TMath.h>
 #include <TPDGCode.h>
-#include <TPythia8.h>
+#include <TLorentzVector.h>
+#include "AliTPythia8.h"
 #include "AliDecayerPythia8.h"
 #include "ParticleData.h"
 
@@ -28,13 +29,37 @@ ClassImp(AliDecayerPythia8)
 Bool_t AliDecayerPythia8::fgInit = kFALSE;
 
 AliDecayerPythia8::AliDecayerPythia8():
-    TPythia8Decayer(),
-    fDecay(kAll),
-    fHeavyFlavour(kTRUE)
+  TVirtualMCDecayer(),
+  fPythia8(new AliTPythia8()),
+  fDebug(0),
+  fDecay(kAll),
+  fHeavyFlavour(kTRUE)
 {
     // Constructor
+   fPythia8->Pythia8()->readString("SoftQCD:elastic = on");
+   fPythia8->Pythia8()->init();
 }
 
+//___________________________________________________________________________
+void AliDecayerPythia8::Decay(Int_t pdg, TLorentzVector* p)
+{
+   // Decay a single particle
+   ClearEvent();
+   AppendParticle(pdg, p);
+   Int_t idPart = fPythia8->Pythia8()->event[0].id();
+   fPythia8->Pythia8()->particleData.mayDecay(idPart,kTRUE);
+   fPythia8->Pythia8()->moreDecays();
+   if (fDebug > 0) fPythia8->EventListing();
+}
+
+//___________________________________________________________________________
+Int_t AliDecayerPythia8::ImportParticles(TClonesArray *particles)
+{
+   //import the decay products into particles array
+   return (fPythia8->ImportParticles(particles, "All"));
+}
+
+
 void AliDecayerPythia8::Init()
 {
 // Initialisation
@@ -51,9 +76,9 @@ void AliDecayerPythia8::Init()
 //    fPythia->ResetDecayTable();
     for (j=0; j < 14; j++) {
        if (fDecay == kNoDecayHeavy) {
-           TPythia8::Instance()->ReadString(Form("%d:onMode = off", heavy[j]));
+           AliTPythia8::Instance()->ReadString(Form("%d:onMode = off", heavy[j]));
        } else {
-           TPythia8::Instance()->ReadString(Form("%d:onMode = on", heavy[j]));
+           AliTPythia8::Instance()->ReadString(Form("%d:onMode = on", heavy[j]));
        }
     }
     
@@ -61,18 +86,18 @@ void AliDecayerPythia8::Init()
 //...Switch off decay of pi0, K0S, Lambda, Sigma+-, Xi0-, Omega-.
     
     if (fDecay != kNeutralPion) {
-       TPythia8::Instance()->ReadString("111:onMode = off");
+       AliTPythia8::Instance()->ReadString("111:onMode = off");
     } else {
-       TPythia8::Instance()->ReadString("111:onMode = on");
+       AliTPythia8::Instance()->ReadString("111:onMode = on");
     }
 
-    TPythia8::Instance()->ReadString("310:onMode = off");
-    TPythia8::Instance()->ReadString("3112:onMode = off");
-    TPythia8::Instance()->ReadString("3212:onMode = off");
-    TPythia8::Instance()->ReadString("3222:onMode = off");
-    TPythia8::Instance()->ReadString("3312:onMode = off");
-    TPythia8::Instance()->ReadString("3322:onMode = off");
-    TPythia8::Instance()->ReadString("3334:onMode = off");
+    AliTPythia8::Instance()->ReadString("310:onMode = off");
+    AliTPythia8::Instance()->ReadString("3112:onMode = off");
+    AliTPythia8::Instance()->ReadString("3212:onMode = off");
+    AliTPythia8::Instance()->ReadString("3222:onMode = off");
+    AliTPythia8::Instance()->ReadString("3312:onMode = off");
+    AliTPythia8::Instance()->ReadString("3322:onMode = off");
+    AliTPythia8::Instance()->ReadString("3334:onMode = off");
 // .. Force decay channels
     ForceDecay();
 }
@@ -85,7 +110,7 @@ void AliDecayerPythia8::ForceDecay()
     if (!fHeavyFlavour) SwitchOffHeavyFlavour();
 //
     Decay_t decay = fDecay;
-    TPythia8::Instance()->ReadString("HadronLevel:Decay = on");
+    AliTPythia8::Instance()->ReadString("HadronLevel:Decay = on");
     
     if (decay == kNoDecayHeavy) return;
 
@@ -95,423 +120,423 @@ void AliDecayerPythia8::ForceDecay()
     {
     case kHardMuons:
 //     B0 -> mu X 
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 13 443 100443");
 //     B+/- -> mu X 
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 13 443 100443");
 //     Bs -> mu X 
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 13 443 100443");
 //     Lambda_b -> mu X 
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 13 443 100443");
 //      Sigma_b- -> mu X 
-       TPythia8::Instance()->ReadString("5132:onMode = off");
-       TPythia8::Instance()->ReadString("5132:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("5132:onMode = off");
+       AliTPythia8::Instance()->ReadString("5132:onIfAny = 13 443 100443");
 //      Sigma_b0 -> mu X
-       TPythia8::Instance()->ReadString("5232:onMode = off");
-       TPythia8::Instance()->ReadString("5232:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("5232:onMode = off");
+       AliTPythia8::Instance()->ReadString("5232:onIfAny = 13 443 100443");
 //      Omega_b  -> mu X
-       TPythia8::Instance()->ReadString("5332:onMode = off");
-       TPythia8::Instance()->ReadString("5332:onIfAny = 13 443 100443");
+       AliTPythia8::Instance()->ReadString("5332:onMode = off");
+       AliTPythia8::Instance()->ReadString("5332:onIfAny = 13 443 100443");
 //      Psi' -> mu+ mu-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAny = 443");
 //      Psi  -> mu+ mu-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 13 13");
 //      D+/- -> mu X
-       TPythia8::Instance()->ReadString("411:onMode = off");
-       TPythia8::Instance()->ReadString("411:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("411:onMode = off");
+       AliTPythia8::Instance()->ReadString("411:onIfAll = 13");
 //      D0   -> mu X
-       TPythia8::Instance()->ReadString("421:onMode = off");
-       TPythia8::Instance()->ReadString("421:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("421:onMode = off");
+       AliTPythia8::Instance()->ReadString("421:onIfAll = 13");
 //      D_s  -> mu X
-       TPythia8::Instance()->ReadString("431:onMode = off");
-       TPythia8::Instance()->ReadString("431:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("431:onMode = off");
+       AliTPythia8::Instance()->ReadString("431:onIfAll = 13");
 //      Lambda_c -> mu X
-       TPythia8::Instance()->ReadString("4122:onMode = off");
-       TPythia8::Instance()->ReadString("4122:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4122:onMode = off");
+       AliTPythia8::Instance()->ReadString("4122:onIfAll = 13");
 //      Sigma_c  -> mu X
-       TPythia8::Instance()->ReadString("4132:onMode = off");
-       TPythia8::Instance()->ReadString("4132:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4132:onMode = off");
+       AliTPythia8::Instance()->ReadString("4132:onIfAll = 13");
 //      Sigma_c+ -> mu X
-       TPythia8::Instance()->ReadString("4232:onMode = off");
-       TPythia8::Instance()->ReadString("4232:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4232:onMode = off");
+       AliTPythia8::Instance()->ReadString("4232:onIfAll = 13");
 //      Omega_c  -> mu X
-       TPythia8::Instance()->ReadString("4332:onMode = off");
-       TPythia8::Instance()->ReadString("4332:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4332:onMode = off");
+       AliTPythia8::Instance()->ReadString("4332:onIfAll = 13");
 
        break;
    case kChiToJpsiGammaToMuonMuon:
 // Chi_1c  -> J/Psi  Gamma
-       TPythia8::Instance()->ReadString("20443:onMode = off");
-       TPythia8::Instance()->ReadString("20443:onIfAll = 443 22");
+       AliTPythia8::Instance()->ReadString("20443:onMode = off");
+       AliTPythia8::Instance()->ReadString("20443:onIfAll = 443 22");
 // Chi_2c  -> J/Psi  Gamma
-       TPythia8::Instance()->ReadString("445:onMode = off");
-       TPythia8::Instance()->ReadString("445:onIfAll = 443 22");
+       AliTPythia8::Instance()->ReadString("445:onMode = off");
+       AliTPythia8::Instance()->ReadString("445:onIfAll = 443 22");
 // J/Psi -> mu+ mu-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 13 13");
        break;
     case kChiToJpsiGammaToElectronElectron:
 // Chi_1c  -> J/Psi  Gamma
-       TPythia8::Instance()->ReadString("20443:onMode = off");
-       TPythia8::Instance()->ReadString("20443:onIfAll = 443 22");
+       AliTPythia8::Instance()->ReadString("20443:onMode = off");
+       AliTPythia8::Instance()->ReadString("20443:onIfAll = 443 22");
 // Chi_2c  -> J/Psi  Gamma
-       TPythia8::Instance()->ReadString("445:onMode = off");
-       TPythia8::Instance()->ReadString("445:onIfAll = 443 22");
+       AliTPythia8::Instance()->ReadString("445:onMode = off");
+       AliTPythia8::Instance()->ReadString("445:onIfAll = 443 22");
 // J/Psi -> e+ e-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 11 11");
        break;
 
     case kBSemiMuonic:
 //      B0 -> mu X 
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 13");
 //     B+/- -> mu X 
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 13");
 //     B_s -> mu X 
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 13");
 //     Lambda_b -> mu X 
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 13");
 //     Sigma_b -> mu X 
-       TPythia8::Instance()->ReadString("5132:onMode = off");
-       TPythia8::Instance()->ReadString("5132:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5132:onMode = off");
+       AliTPythia8::Instance()->ReadString("5132:onIfAny = 13");
 //     Sigma_b0 -> mu X 
-       TPythia8::Instance()->ReadString("5232:onMode = off");
-       TPythia8::Instance()->ReadString("5232:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5232:onMode = off");
+       AliTPythia8::Instance()->ReadString("5232:onIfAny = 13");
 //     Omega_b  -> mu X 
-       TPythia8::Instance()->ReadString("5332:onMode = off");
-       TPythia8::Instance()->ReadString("5332:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5332:onMode = off");
+       AliTPythia8::Instance()->ReadString("5332:onIfAny = 13");
        break;
     case kSemiMuonic:
 //      D+- -> mu X
-       TPythia8::Instance()->ReadString("411:onMode = off");
-       TPythia8::Instance()->ReadString("411:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("411:onMode = off");
+       AliTPythia8::Instance()->ReadString("411:onIfAll = 13");
 //      D0  -> mu X
-       TPythia8::Instance()->ReadString("421:onMode = off");
-       TPythia8::Instance()->ReadString("421:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("421:onMode = off");
+       AliTPythia8::Instance()->ReadString("421:onIfAll = 13");
 //      D_s  -> mu X
-       TPythia8::Instance()->ReadString("431:onMode = off");
-       TPythia8::Instance()->ReadString("431:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("431:onMode = off");
+       AliTPythia8::Instance()->ReadString("431:onIfAll = 13");
 //      Lambda_c -> mu X
-       TPythia8::Instance()->ReadString("4122:onMode = off");
-       TPythia8::Instance()->ReadString("4122:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4122:onMode = off");
+       AliTPythia8::Instance()->ReadString("4122:onIfAll = 13");
 //      Sigma_c  -> mu X
-       TPythia8::Instance()->ReadString("4132:onMode = off");
-       TPythia8::Instance()->ReadString("4132:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4132:onMode = off");
+       AliTPythia8::Instance()->ReadString("4132:onIfAll = 13");
 //      Sigma  -> mu X
-       TPythia8::Instance()->ReadString("4232:onMode = off");
-       TPythia8::Instance()->ReadString("4232:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4232:onMode = off");
+       AliTPythia8::Instance()->ReadString("4232:onIfAll = 13");
 //      Omega_c  -> mu X
-       TPythia8::Instance()->ReadString("4332:onMode = off");
-       TPythia8::Instance()->ReadString("4332:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4332:onMode = off");
+       AliTPythia8::Instance()->ReadString("4332:onIfAll = 13");
 //      B0       -> mu X
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 13");
 //      B+/-     -> mu X
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 13");
 //      B_s      -> mu X
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 13");
 //      Lambda_c -> mu X
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 13");
 //      Sigma_c  -> mu X
-       TPythia8::Instance()->ReadString("5132:onMode = off");
-       TPythia8::Instance()->ReadString("5132:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5132:onMode = off");
+       AliTPythia8::Instance()->ReadString("5132:onIfAny = 13");
 //      Sigma_c  -> mu X
-       TPythia8::Instance()->ReadString("5232:onMode = off");
-       TPythia8::Instance()->ReadString("5232:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5232:onMode = off");
+       AliTPythia8::Instance()->ReadString("5232:onIfAny = 13");
 //      Omega_c  -> mu X
-       TPythia8::Instance()->ReadString("5332:onMode = off");
-       TPythia8::Instance()->ReadString("5332:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("5332:onMode = off");
+       AliTPythia8::Instance()->ReadString("5332:onIfAny = 13");
 
        break;
     case kDiMuon:
 //      Rho -> mu+ mu-
-       TPythia8::Instance()->ReadString("113:onMode = off");
-       TPythia8::Instance()->ReadString("113:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("113:onMode = off");
+       AliTPythia8::Instance()->ReadString("113:onIfAll = 13 13");
 //      Eta-> mu+ mu-
-       TPythia8::Instance()->ReadString("221:onMode = off");
-       TPythia8::Instance()->ReadString("221:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("221:onMode = off");
+       AliTPythia8::Instance()->ReadString("221:onIfAll = 13 13");
 //      omega-> mu+ mu-
-       TPythia8::Instance()->ReadString("223:onMode = off");
-       TPythia8::Instance()->ReadString("223:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("223:onMode = off");
+       AliTPythia8::Instance()->ReadString("223:onIfAll = 13 13");
 //      phi-> mu+ mu-
-       TPythia8::Instance()->ReadString("333:onMode = off");
-       TPythia8::Instance()->ReadString("333:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("333:onMode = off");
+       AliTPythia8::Instance()->ReadString("333:onIfAll = 13 13");
 //      J/Psi-> mu+ mu-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 13 13");
 //      Psi'-> mu+ mu-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
 //      Ups-> mu+ mu-
-       TPythia8::Instance()->ReadString("553:onMode = off");
-       TPythia8::Instance()->ReadString("553:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("553:onMode = off");
+       AliTPythia8::Instance()->ReadString("553:onIfAll = 13 13");
 //      Ups'-> mu+ mu-
-       TPythia8::Instance()->ReadString("100553:onMode = off");
-       TPythia8::Instance()->ReadString("100553:onIfAll = 13 13"); 
+       AliTPythia8::Instance()->ReadString("100553:onMode = off");
+       AliTPythia8::Instance()->ReadString("100553:onIfAll = 13 13"); 
 //      Ups''-> mu+ mu-
-       TPythia8::Instance()->ReadString("200553:onMode = off");
-       TPythia8::Instance()->ReadString("200553:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("200553:onMode = off");
+       AliTPythia8::Instance()->ReadString("200553:onIfAll = 13 13");
        break;
     case kBSemiElectronic:
 //      B0 - > e+ e-
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 11");
 //      B+- -> e+ e-
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 11");
 //      B_s -> e+ e-
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 11");
 //      Lambda_b -> e+ e-
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 11");
 //      Sigma_b -> e+ e-
-       TPythia8::Instance()->ReadString("5132:onMode = off");
-       TPythia8::Instance()->ReadString("5132:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5132:onMode = off");
+       AliTPythia8::Instance()->ReadString("5132:onIfAny = 11");
 //      Sigma_b -> e+ e-
-       TPythia8::Instance()->ReadString("5232:onMode = off");
-       TPythia8::Instance()->ReadString("5232:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5232:onMode = off");
+       AliTPythia8::Instance()->ReadString("5232:onIfAny = 11");
 //      Omega_b ->e+ e-
-       TPythia8::Instance()->ReadString("5332:onMode = off");
-       TPythia8::Instance()->ReadString("5332:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5332:onMode = off");
+       AliTPythia8::Instance()->ReadString("5332:onIfAny = 11");
        break;
     case kSemiElectronic:
 //      D+/- -> e X
-       TPythia8::Instance()->ReadString("411:onMode = off");
-       TPythia8::Instance()->ReadString("411:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("411:onMode = off");
+       AliTPythia8::Instance()->ReadString("411:onIfAll = 11");
 //      D0 -> e X
-       TPythia8::Instance()->ReadString("421:onMode = off");
-       TPythia8::Instance()->ReadString("421:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("421:onMode = off");
+       AliTPythia8::Instance()->ReadString("421:onIfAll = 11");
 //      D_s ->e X
-       TPythia8::Instance()->ReadString("431:onMode = off");
-       TPythia8::Instance()->ReadString("431:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("431:onMode = off");
+       AliTPythia8::Instance()->ReadString("431:onIfAll = 11");
 //      Lambda_c -> e X
-       TPythia8::Instance()->ReadString("4122:onMode = off");
-       TPythia8::Instance()->ReadString("4122:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("4122:onMode = off");
+       AliTPythia8::Instance()->ReadString("4122:onIfAll = 11");
 //      Sigma_c -> e X
-       TPythia8::Instance()->ReadString("4132:onMode = off");
-       TPythia8::Instance()->ReadString("4132:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("4132:onMode = off");
+       AliTPythia8::Instance()->ReadString("4132:onIfAll = 11");
 //      Sigma_c -> e X
-       TPythia8::Instance()->ReadString("4232:onMode = off");
-       TPythia8::Instance()->ReadString("4232:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("4232:onMode = off");
+       AliTPythia8::Instance()->ReadString("4232:onIfAll = 11");
 //      Omega_c -> e X
-       TPythia8::Instance()->ReadString("4332:onMode = off");
-       TPythia8::Instance()->ReadString("4332:onIfAll = 11");
+       AliTPythia8::Instance()->ReadString("4332:onMode = off");
+       AliTPythia8::Instance()->ReadString("4332:onIfAll = 11");
 //      B0 -> e X
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 11");
 //      B+/- -> e X
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 11");
 //      B_s -> e X
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 11");
 //      Lambda_b -> e X
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 11");
 //      Sigma_b -> e X
-       TPythia8::Instance()->ReadString("5132:onMode = off");
-       TPythia8::Instance()->ReadString("5132:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5132:onMode = off");
+       AliTPythia8::Instance()->ReadString("5132:onIfAny = 11");
 //      Sigma_b -> e X
-       TPythia8::Instance()->ReadString("5232:onMode = off");
-       TPythia8::Instance()->ReadString("5232:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5232:onMode = off");
+       AliTPythia8::Instance()->ReadString("5232:onIfAny = 11");
 //      Omega_b -> e X
-       TPythia8::Instance()->ReadString("5332:onMode = off");
-       TPythia8::Instance()->ReadString("5332:onIfAny = 11");
+       AliTPythia8::Instance()->ReadString("5332:onMode = off");
+       AliTPythia8::Instance()->ReadString("5332:onIfAny = 11");
        break;
     case kDiElectron:
 //      Rho -> e+e-
-       TPythia8::Instance()->ReadString("113:onMode = off");
-       TPythia8::Instance()->ReadString("113:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("113:onMode = off");
+       AliTPythia8::Instance()->ReadString("113:onIfAll = 11 11");
 //      Eta -> e+e-
-       TPythia8::Instance()->ReadString("221:onMode = off");
-       TPythia8::Instance()->ReadString("221:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("221:onMode = off");
+       AliTPythia8::Instance()->ReadString("221:onIfAll = 11 11");
 //      omega -> e+e-
-       TPythia8::Instance()->ReadString("223:onMode = off");
-       TPythia8::Instance()->ReadString("223:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("223:onMode = off");
+       AliTPythia8::Instance()->ReadString("223:onIfAll = 11 11");
 //      phi -> e+e-
-       TPythia8::Instance()->ReadString("333:onMode = off");
-       TPythia8::Instance()->ReadString("333:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("333:onMode = off");
+       AliTPythia8::Instance()->ReadString("333:onIfAll = 11 11");
 //      J/Psi -> e+e-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 11 11");
 //      Psi' -> e+e-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAll = 11 11");
 //      Ups -> e+e-
-       TPythia8::Instance()->ReadString("553:onMode = off");
-       TPythia8::Instance()->ReadString("553:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("553:onMode = off");
+       AliTPythia8::Instance()->ReadString("553:onIfAll = 11 11");
 //      Ups' -> e+e-
-       TPythia8::Instance()->ReadString("100553:onMode = off");
-       TPythia8::Instance()->ReadString("100553:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("100553:onMode = off");
+       AliTPythia8::Instance()->ReadString("100553:onIfAll = 11 11");
 //      Ups'' -> e+e-
-       TPythia8::Instance()->ReadString("200553:onMode = off");
-       TPythia8::Instance()->ReadString("200553:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("200553:onMode = off");
+       AliTPythia8::Instance()->ReadString("200553:onIfAll = 11 11");
        break;
     case kBJpsiDiMuon:
 //      B0   -> J/Psi (Psi') X   
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 443 100443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 443 100443");
 //      B+/-   -> J/Psi (Psi') X   
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 443 100443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 443 100443");
 //      B_s   -> J/Psi (Psi') X   
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 443 100443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 443 100443");
 //      Lambda_b -> J/Psi (Psi') X   
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 443 100443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 443 100443");
 //
 //      J/Psi -> mu+ mu-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 13 13");
 //      Psi' -> mu+ mu-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
        break;
     case kBPsiPrimeDiMuon:
 //      B0   -> Psi' X   
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 100443");
 //      B+/-   -> Psi' X   
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 100443");
 //      B_s   -> Psi'  X   
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 100443");
 //      Lambda_b -> Psi' X   
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 100443");
 //
 //      Psi' -> mu+ mu-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAll = 13 13");
        break;
     case kBJpsiDiElectron:
 //      B0   -> Psi X   
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 443");
 //      B+/-   -> Psi X   
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 443");
 //      B_s   -> Psi  X   
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 443");
 //      Lambda_b -> Psi X   
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 443");
 //
 //      Psi -> mu+ mu-
-       TPythia8::Instance()->ReadString("443:onMode = off");
-       TPythia8::Instance()->ReadString("443:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("443:onMode = off");
+       AliTPythia8::Instance()->ReadString("443:onIfAll = 11 11");
 
        break;
     case kBJpsi:
 //      B0   -> Psi X   
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 443");
 //      B+/-   -> Psi X   
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 443");
 //      B_s   -> Psi  X   
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 443");
 //      Lambda_b -> Psi X   
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 443");
        break;
     case kBPsiPrimeDiElectron:
 //      B0   -> Psi' X   
-       TPythia8::Instance()->ReadString("511:onMode = off");
-       TPythia8::Instance()->ReadString("511:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("511:onMode = off");
+       AliTPythia8::Instance()->ReadString("511:onIfAny = 100443");
 //      B+/-   -> Psi' X   
-       TPythia8::Instance()->ReadString("521:onMode = off");
-       TPythia8::Instance()->ReadString("521:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("521:onMode = off");
+       AliTPythia8::Instance()->ReadString("521:onIfAny = 100443");
 //      B_s   -> Psi'  X   
-       TPythia8::Instance()->ReadString("531:onMode = off");
-       TPythia8::Instance()->ReadString("531:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("531:onMode = off");
+       AliTPythia8::Instance()->ReadString("531:onIfAny = 100443");
 //      Lambda_b -> Psi' X   
-       TPythia8::Instance()->ReadString("5122:onMode = off");
-       TPythia8::Instance()->ReadString("5122:onIfAny = 100443");
+       AliTPythia8::Instance()->ReadString("5122:onMode = off");
+       AliTPythia8::Instance()->ReadString("5122:onIfAny = 100443");
 //
 //      Psi' -> mu+ mu-
-       TPythia8::Instance()->ReadString("100443:onMode = off");
-       TPythia8::Instance()->ReadString("100443:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("100443:onMode = off");
+       AliTPythia8::Instance()->ReadString("100443:onIfAll = 11 11");
        break;
     case kPiToMu:
 //      pi -> mu nu
-       TPythia8::Instance()->ReadString("211:onMode = off");
-       TPythia8::Instance()->ReadString("211:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("211:onMode = off");
+       AliTPythia8::Instance()->ReadString("211:onIfAny = 13");
        break;
     case kKaToMu:
 //      K -> mu nu
-       TPythia8::Instance()->ReadString("321:onMode = off");
-       TPythia8::Instance()->ReadString("321:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("321:onMode = off");
+       AliTPythia8::Instance()->ReadString("321:onIfAny = 13");
        break;
     case kAllMuonic:
 //      pi/K -> mu
-       TPythia8::Instance()->ReadString("211:onMode = off");
-       TPythia8::Instance()->ReadString("211:onIfAny = 13");
-       TPythia8::Instance()->ReadString("321:onMode = off");
-       TPythia8::Instance()->ReadString("321:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("211:onMode = off");
+       AliTPythia8::Instance()->ReadString("211:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("321:onMode = off");
+       AliTPythia8::Instance()->ReadString("321:onIfAny = 13");
        break;
     case kWToMuon:
 //      W -> mu X
-       TPythia8::Instance()->ReadString("24:onMode = off");
-       TPythia8::Instance()->ReadString("24:onIfAny = 13");
+       AliTPythia8::Instance()->ReadString("24:onMode = off");
+       AliTPythia8::Instance()->ReadString("24:onIfAny = 13");
        break;
     case kWToCharm:
 //      W -> c X
-       TPythia8::Instance()->ReadString("24:onMode = off");
-       TPythia8::Instance()->ReadString("24:onIfAny = 4");
+       AliTPythia8::Instance()->ReadString("24:onMode = off");
+       AliTPythia8::Instance()->ReadString("24:onIfAny = 4");
        break;
     case kWToCharmToMuon:
 //      W -> c X
-       TPythia8::Instance()->ReadString("24:onMode = off");
-       TPythia8::Instance()->ReadString("24:onIfAny = 4");
+       AliTPythia8::Instance()->ReadString("24:onMode = off");
+       AliTPythia8::Instance()->ReadString("24:onIfAny = 4");
 //      D+- -> mu X
-       TPythia8::Instance()->ReadString("411:onMode = off");
-       TPythia8::Instance()->ReadString("411:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("411:onMode = off");
+       AliTPythia8::Instance()->ReadString("411:onIfAll = 13");
 //      D0 -> mu X
-       TPythia8::Instance()->ReadString("421:onMode = off");
-       TPythia8::Instance()->ReadString("421:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("421:onMode = off");
+       AliTPythia8::Instance()->ReadString("421:onIfAll = 13");
 //      D_s -> mu X
-       TPythia8::Instance()->ReadString("431:onMode = off");
-       TPythia8::Instance()->ReadString("431:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("431:onMode = off");
+       AliTPythia8::Instance()->ReadString("431:onIfAll = 13");
 //      Lambda_c -> mu X
-       TPythia8::Instance()->ReadString("4122:onMode = off");
-       TPythia8::Instance()->ReadString("4122:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4122:onMode = off");
+       AliTPythia8::Instance()->ReadString("4122:onIfAll = 13");
 //      Sigma_c -> mu X
-       TPythia8::Instance()->ReadString("4132:onMode = off");
-       TPythia8::Instance()->ReadString("4132:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4132:onMode = off");
+       AliTPythia8::Instance()->ReadString("4132:onIfAll = 13");
 //      Sigma_c -> mu X
-       TPythia8::Instance()->ReadString("4232:onMode = off");
-       TPythia8::Instance()->ReadString("4232:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4232:onMode = off");
+       AliTPythia8::Instance()->ReadString("4232:onIfAll = 13");
 //      Omega_c -> mu X
-       TPythia8::Instance()->ReadString("4332:onMode = off");
-       TPythia8::Instance()->ReadString("4332:onIfAll = 13");
+       AliTPythia8::Instance()->ReadString("4332:onMode = off");
+       AliTPythia8::Instance()->ReadString("4332:onIfAll = 13");
        break;
     case kZDiMuon:
 //      Z -> mu+ mu-
-       TPythia8::Instance()->ReadString("23:onMode = off");
-       TPythia8::Instance()->ReadString("23:onIfAll = 13 13");
+       AliTPythia8::Instance()->ReadString("23:onMode = off");
+       AliTPythia8::Instance()->ReadString("23:onIfAll = 13 13");
        break;
     case kZDiElectron:
 //      Z -> e+ e-
-       TPythia8::Instance()->ReadString("23:onMode = off");
-       TPythia8::Instance()->ReadString("23:onIfAll = 11 11");
+       AliTPythia8::Instance()->ReadString("23:onMode = off");
+       AliTPythia8::Instance()->ReadString("23:onIfAll = 11 11");
        break;
     case kHadronicD:
        ForceHadronicD(1);
@@ -521,21 +546,21 @@ void AliDecayerPythia8::ForceDecay()
        break;
     case kPhiKK:
        // Phi-> K+ K-
-       TPythia8::Instance()->ReadString("333:onMode = off");
-       TPythia8::Instance()->ReadString("333:onIfAll = 321 321");
+       AliTPythia8::Instance()->ReadString("333:onMode = off");
+       AliTPythia8::Instance()->ReadString("333:onIfAll = 321 321");
        break;
     case kOmega:
        // Omega -> Lambda K
-       TPythia8::Instance()->ReadString("3334:onMode = off");
-       TPythia8::Instance()->ReadString("3334:onIfAll = 3122 321 ");
+       AliTPythia8::Instance()->ReadString("3334:onMode = off");
+       AliTPythia8::Instance()->ReadString("3334:onIfAll = 3122 321 ");
     case kLambda:
        // Lambda -> p pi-
-       TPythia8::Instance()->ReadString("3122:onMode = off");
-       TPythia8::Instance()->ReadString("3122:onIfAll = 2212 211 ");
+       AliTPythia8::Instance()->ReadString("3122:onMode = off");
+       AliTPythia8::Instance()->ReadString("3122:onIfAll = 2212 211 ");
     case kAll:
        break;
     case kNoDecay:
-       TPythia8::Instance()->ReadString("HadronLevel:Decay = off");
+       AliTPythia8::Instance()->ReadString("HadronLevel:Decay = off");
        break;
     case kNoDecayHeavy:
     case kNoDecayBeauty:
@@ -549,18 +574,16 @@ Float_t AliDecayerPythia8::GetPartialBranchingRatio(Int_t ipart)
 {
     // Get the partial branching ration for the forced decay channels
     
-    Pythia8::Pythia* thePythia       = TPythia8::Instance()->Pythia8();
-    Pythia8::ParticleDataTable table = thePythia->particleData;
-    Pythia8::ParticleDataEntry* pd   = table.particleDataPtr(ipart);
-    Pythia8::DecayTable  decays      = pd->decay;
-    
-    
-    Int_t nc = decays.size();
+    Pythia8::Pythia* thePythia       = AliTPythia8::Instance()->Pythia8();
+    Pythia8::ParticleData & table    = thePythia->particleData;
+    Pythia8::ParticleDataEntry* pd   = table.particleDataEntryPtr(ipart);
+
+    Int_t nc = pd->sizeChannels();
     Float_t br = 0.;
 //
 //  Loop over decay channels
     for (Int_t ic = 0; ic < nc; ic++) {
-       Pythia8::DecayChannel& decCh = decays[ic];
+      Pythia8::DecayChannel& decCh = pd->channel(ic);
        for (Int_t i = 0; i < decCh.multiplicity(); i++) {
            br += decCh.bRatio();
        }
@@ -572,10 +595,10 @@ Float_t AliDecayerPythia8::GetPartialBranchingRatio(Int_t ipart)
 Float_t AliDecayerPythia8::GetLifetime(Int_t kf)
 {
     // Return lifetime of particle
-    Pythia8::Pythia* thePythia       = TPythia8::Instance()->Pythia8();
-    Pythia8::ParticleDataTable table = thePythia->particleData;
+    Pythia8::Pythia* thePythia       = AliTPythia8::Instance()->Pythia8();
+    Pythia8::ParticleData& table     = thePythia->particleData;
     Float_t tau = table.tau0(kf);
-    return ( tau);
+    return (tau);
 }
 
 void  AliDecayerPythia8::SwitchOffHeavyFlavour()
@@ -583,11 +606,11 @@ void  AliDecayerPythia8::SwitchOffHeavyFlavour()
     // Switch off heavy flavour production
     //
 // Maximum number of quark flavours used in pdf 
-    TPythia8::Instance()->ReadString("PDFinProcess:nQuarkIn = 3");
+    AliTPythia8::Instance()->ReadString("PDFinProcess:nQuarkIn = 3");
 // Maximum number of flavors that can be used in showers
-    TPythia8::Instance()->ReadString("SpaceShower:nQuarkIn = 3");
-    TPythia8::Instance()->ReadString("TimeShower:nGammaToQuark = 3");
-    TPythia8::Instance()->ReadString("TimeShower:nGluonToQuark = 3");
+    AliTPythia8::Instance()->ReadString("SpaceShower:nQuarkIn = 3");
+    AliTPythia8::Instance()->ReadString("TimeShower:nGammaToQuark = 3");
+    AliTPythia8::Instance()->ReadString("TimeShower:nGluonToQuark = 3");
 }
 
 
@@ -597,59 +620,81 @@ void AliDecayerPythia8::ForceHadronicD(Int_t optUse4Bodies)
 // Force golden D decay modes
 //
     // K* -> K pi
-    TPythia8::Instance()->ReadString("313:onMode = off");
-    TPythia8::Instance()->ReadString("313:onIfAll = 321 211");
+    AliTPythia8::Instance()->ReadString("313:onMode = off");
+    AliTPythia8::Instance()->ReadString("313:onIfAll = 321 211");
     // for Ds -> Phi pi+
-    TPythia8::Instance()->ReadString("333:onMode = off");
-    TPythia8::Instance()->ReadString("333:onIfAll = 321 321");
+    AliTPythia8::Instance()->ReadString("333:onMode = off");
+    AliTPythia8::Instance()->ReadString("333:onIfAll = 321 321");
     // for D0 -> rho0 pi+ k-
-    TPythia8::Instance()->ReadString("113:onMode = off");
-    TPythia8::Instance()->ReadString("113:onIfAll = 211 211");
+    AliTPythia8::Instance()->ReadString("113:onMode = off");
+    AliTPythia8::Instance()->ReadString("113:onIfAll = 211 211");
     // for Lambda_c -> Delta++ K-
-    TPythia8::Instance()->ReadString("2224:onMode = off");
-    TPythia8::Instance()->ReadString("2224:onIfAll = 2212 211");
+    AliTPythia8::Instance()->ReadString("2224:onMode = off");
+    AliTPythia8::Instance()->ReadString("2224:onIfAll = 2212 211");
     // for Lambda_c -> Lambda(1520) K-
-    TPythia8::Instance()->ReadString("3124:onMode = off");
-    TPythia8::Instance()->ReadString("3124:onIfAll = 2212 321");
+    AliTPythia8::Instance()->ReadString("3124:onMode = off");
+    AliTPythia8::Instance()->ReadString("3124:onIfAll = 2212 321");
 
 
-    TPythia8::Instance()->ReadString("411:onMode = off");
-    TPythia8::Instance()->ReadString("421:onMode = off");
-    TPythia8::Instance()->ReadString("431:onMode = off");
-    TPythia8::Instance()->ReadString("4112:onMode = off");
-    TPythia8::Instance()->ReadString("4122:onMode = off");
+    AliTPythia8::Instance()->ReadString("411:onMode = off");
+    AliTPythia8::Instance()->ReadString("421:onMode = off");
+    AliTPythia8::Instance()->ReadString("431:onMode = off");
+    AliTPythia8::Instance()->ReadString("4112:onMode = off");
+    AliTPythia8::Instance()->ReadString("4122:onMode = off");
 
     // D+/- -> K pi pi 
-    TPythia8::Instance()->ReadString("411:onIfMatch = 321 211 211");
+    AliTPythia8::Instance()->ReadString("411:onIfMatch = 321 211 211");
     // D+/- -> K* pi
-    TPythia8::Instance()->ReadString("411:onIfMatch = 313 211");
+    AliTPythia8::Instance()->ReadString("411:onIfMatch = 313 211");
     // D0 -> K pi
-    TPythia8::Instance()->ReadString("421:onIfMatch = 321 211");
+    AliTPythia8::Instance()->ReadString("421:onIfMatch = 321 211");
 
     if (optUse4Bodies) {
        // D0 -> K pi pi pi
-       TPythia8::Instance()->ReadString("421:onIfMatch = 321 211 211 211");
+       AliTPythia8::Instance()->ReadString("421:onIfMatch = 321 211 211 211");
        // D0 -> K pi rho
-       TPythia8::Instance()->ReadString("421:onIfMatch = 321 211 113");
+       AliTPythia8::Instance()->ReadString("421:onIfMatch = 321 211 113");
        // D0 -> K*0 pi pi
-       TPythia8::Instance()->ReadString("421:onIfMatch = 313 211 211");
+       AliTPythia8::Instance()->ReadString("421:onIfMatch = 313 211 211");
     }
     
     // D_s -> K K*
-    TPythia8::Instance()->ReadString("431:onIfMatch = 321 313");
+    AliTPythia8::Instance()->ReadString("431:onIfMatch = 321 313");
     // D_s -> Phi pi
-    TPythia8::Instance()->ReadString("431:onIfMatch = 333 211");
+    AliTPythia8::Instance()->ReadString("431:onIfMatch = 333 211");
 
     // Lambda_c -> p K*
-    TPythia8::Instance()->ReadString("4122:onIfMatch = 2212 313");
+    AliTPythia8::Instance()->ReadString("4122:onIfMatch = 2212 313");
     // Lambda_c -> Delta K
-    TPythia8::Instance()->ReadString("4122:onIfMatch = 2224 321");
+    AliTPythia8::Instance()->ReadString("4122:onIfMatch = 2224 321");
     // Lambda_c -> Lambda(1520) pi
-    TPythia8::Instance()->ReadString("4122:onIfMatch = 3124 211");
+    AliTPythia8::Instance()->ReadString("4122:onIfMatch = 3124 211");
     // Lambda_c -> p K pi
-    TPythia8::Instance()->ReadString("4122:onIfMatch = 2212 321 211");
+    AliTPythia8::Instance()->ReadString("4122:onIfMatch = 2212 321 211");
     // Lambda_c -> Lambda pi 
-    TPythia8::Instance()->ReadString("4122:onIfMatch = 3122 211");
+    AliTPythia8::Instance()->ReadString("4122:onIfMatch = 3122 211");
 
 }
 
+//___________________________________________________________________________
+void    AliDecayerPythia8::ReadDecayTable()
+{
+   //to read a decay table (not yet implemented)
+}
+
+
+//___________________________________________________________________________
+void AliDecayerPythia8::AppendParticle(Int_t pdg, TLorentzVector* p)
+{
+   // Append a particle to the stack
+   fPythia8->Pythia8()->event.append(pdg, 11, 0, 0, p->Px(), p->Py(), p->Pz(), p->E(), p->M());   
+}
+
+
+//___________________________________________________________________________
+void AliDecayerPythia8::ClearEvent()
+{
+   // Clear the event stack
+   fPythia8->Pythia8()->event.clear();
+}
+
index 8582024..40e58ab 100644 (file)
@@ -8,28 +8,40 @@
 // Implementation of TVirtualMCDecayer using Pythia8
 // Author: andreas.morsch@cern.ch
 
-#include <TPythia8Decayer.h>
 #include <ParticleData.h>
+#include <TVirtualMCDecayer.h>
 #include "AliDecayer.h"
 
-class AliDecayerPythia8 : public TPythia8Decayer {
+class AliDecayerPythia8 : public TVirtualMCDecayer {
  public:
   AliDecayerPythia8();
   virtual ~AliDecayerPythia8(){;}
   virtual void    Init();
+  virtual void    Decay(Int_t pdg, TLorentzVector* p);
+  virtual Int_t   ImportParticles(TClonesArray *particles);
   virtual void    SetForceDecay(Decay_t decay) {fDecay=decay;}
   virtual void    SetForceDecay(Int_t decay)   {SetForceDecay((Decay_t) decay);}
   virtual void    ForceDecay();
   virtual Float_t GetPartialBranchingRatio(Int_t ipart);
   virtual void    HeavyFlavourOff() {fHeavyFlavour = kFALSE;}
   virtual Float_t GetLifetime(Int_t kf);
+  virtual void    ReadDecayTable();
+
+  virtual void    SetDebugLevel(Int_t debug) {fDebug = debug;}
+
+ protected:
+   void AppendParticle(Int_t pdg, TLorentzVector* p);
+   void ClearEvent(); 
  private:
   void     SwitchOffHeavyFlavour();
   void     ForceHadronicD(Int_t optUser4Bodies = 1);
- protected:
-  Decay_t     fDecay;           //  Forced decay mode
-  Bool_t      fHeavyFlavour;    //! Flag for heavy flavors
-  static Bool_t fgInit;         //! initialization flag 
+
+  AliTPythia8*  fPythia8;          // Pointer to pythia8
+  Int_t         fDebug;            // Debug level
+  Decay_t       fDecay;            //  Forced decay mode
+  Bool_t        fHeavyFlavour;     //! Flag for heavy flavors
+  static Bool_t fgInit;            //! initialization flag 
   ClassDef(AliDecayerPythia8, 1) // Particle Decayer using Pythia8
 };
 #endif
index 7071693..a57bd8c 100644 (file)
@@ -53,7 +53,7 @@ ClassImp(AliPythia8)
 AliPythia8* AliPythia8::fgAliPythia8=NULL;
 
 AliPythia8::AliPythia8():
-    TPythia8(),
+    AliTPythia8(),
     AliPythiaBase(),
     fProcess(kPyMb),
     fEcms(0.),
@@ -74,7 +74,7 @@ AliPythia8::AliPythia8():
 }
 
 AliPythia8::AliPythia8(const AliPythia8& pythia):
-    TPythia8(), 
+    AliTPythia8(), 
     AliPythiaBase(),
     fProcess(kPyMb),
     fEcms(0.),
@@ -594,7 +594,7 @@ void AliPythia8::GetJet(Int_t i, Float_t& px, Float_t& py, Float_t& pz, Float_t&
 void AliPythia8::GenerateEvent()
 {
     // Generate one event
-    TPythia8::GenerateEvent();
+    AliTPythia8::GenerateEvent();
 }
 
 void AliPythia8::GenerateMIEvent()
@@ -606,13 +606,13 @@ void AliPythia8::GenerateMIEvent()
 void AliPythia8::PrintStatistics()
 {
     // End of run statistics
-    TPythia8::PrintStatistics();
+    AliTPythia8::PrintStatistics();
 }
 
 void AliPythia8::EventListing()
 {
     // End of run statistics
-    TPythia8::EventListing();
+    AliTPythia8::EventListing();
 }
 
 Int_t AliPythia8::ProcessCode()
index bd3ed6f..2f5f348 100644 (file)
@@ -5,12 +5,12 @@
 
 /* $Id: AliPythia.h,v 1.22 2007/10/09 08:43:24 morsch Exp $ */
 
-#include <TPythia8.h>
 #include "Analysis.h"
 #include "AliPythiaBase.h"
+#include "AliTPythia8.h"
 
 class AliStack;
-class AliPythia8 : public TPythia8, public AliPythiaBase
+class AliPythia8 :public AliTPythia8, public AliPythiaBase
 {
 
  public:
index 089c96a..5dca74a 100644 (file)
@@ -2,6 +2,7 @@
 #pragma link off all globals;
 #pragma link off all classes;
 #pragma link off all functions;
+#pragma link C++ class AliTPythia8+;
 #pragma link C++ class AliPythia8+;
 #pragma link C++ class AliDecayerPythia8+;
 #endif
diff --git a/PYTHIA8/AliTPythia8.cxx b/PYTHIA8/AliTPythia8.cxx
new file mode 100644 (file)
index 0000000..0de8209
--- /dev/null
@@ -0,0 +1,300 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// Author: Andreas Morsch   27/10/2007
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// TPythia8                                                                   //
+//                                                                            //
+// TPythia is an interface class to C++ version of Pythia 8.1                 //
+// event generators, written by T.Sjostrand.                                  //
+//                                                                            //
+// The user is assumed to be familiar with the Pythia package.                //
+// This class includes only a basic interface to Pythia8. Because Pythia8 is  //
+// also written in C++, its functions/classes can be called directly from a   //
+// compiled C++ script.                                                       //
+// To call Pythia functions not available in this interface a dictionary must //
+// be generated.                                                              //
+// see $ROOTSYS/tutorials/pythia/pythia8.C for an example of use from CINT.   //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+/*
+*------------------------------------------------------------------------------------*
+ |                                                                                    |
+ |  *------------------------------------------------------------------------------*  |
+ |  |                                                                              |  |
+ |  |                                                                              |  |
+ |  |   PPP   Y   Y  TTTTT  H   H  III    A      Welcome to the Lund Monte Carlo!  |  |
+ |  |   P  P   Y Y     T    H   H   I    A A     This is PYTHIA version 8.100      |  |
+ |  |   PPP     Y      T    HHHHH   I   AAAAA    Last date of change: 20 Oct 2007  |  |
+ |  |   P       Y      T    H   H   I   A   A                                      |  |
+ |  |   P       Y      T    H   H  III  A   A    Now is 27 Oct 2007 at 18:26:53    |  |
+ |  |                                                                              |  |
+ |  |   Main author: Torbjorn Sjostrand; CERN/PH, CH-1211 Geneva, Switzerland,     |  |
+ |  |     and Department of Theoretical Physics, Lund University, Lund, Sweden;    |  |
+ |  |     phone: + 41 - 22 - 767 82 27; e-mail: torbjorn@thep.lu.se                |  |
+ |  |   Author: Stephen Mrenna; Computing Division, Simulations Group,             |  |
+ |  |     Fermi National Accelerator Laboratory, MS 234, Batavia, IL 60510, USA;   |  |
+ |  |     phone: + 1 - 630 - 840 - 2556; e-mail: mrenna@fnal.gov                   |  |
+ |  |   Author: Peter Skands; CERN/PH, CH-1211 Geneva, Switzerland,                |  |
+ |  |     and Theoretical Physics Department,                                      |  |
+ |  |     Fermi National Accelerator Laboratory, MS 106, Batavia, IL 60510, USA;   |  |
+ |  |     phone: + 41 - 22 - 767 24 59; e-mail: skands@fnal.gov                    |  |
+ |  |                                                                              |  |
+ |  |   The main program reference is the 'Brief Introduction to PYTHIA 8.1',      |  |
+ |  |   T. Sjostrand, S. Mrenna and P. Skands, arXiv:0710.3820                     |  |
+ |  |                                                                              |  |
+ |  |   The main physics reference is the 'PYTHIA 6.4 Physics and Manual',         |  |
+ |  |   T. Sjostrand, S. Mrenna and P. Skands, JHEP05 (2006) 026 [hep-ph/0603175]. |  |
+ |  |                                                                              |  |
+ |  |   An archive of program versions and documentation is found on the web:      |  |
+ |  |   http://www.thep.lu.se/~torbjorn/Pythia.html                                |  |
+ |  |                                                                              |  |
+ |  |   This program is released under the GNU General Public Licence version 2.   |  |
+ |  |   Please respect the MCnet Guidelines for Event Generator Authors and Users. |  |
+ |  |                                                                              |  |
+ |  |   Disclaimer: this program comes without any guarantees.                     |  |
+ |  |   Beware of errors and use common sense when interpreting results.           |  |
+ |  |                                                                              |  |
+ |  |   Copyright (C) 2007 Torbjorn Sjostrand                                      |  |
+ |  |                                                                              |  |
+ |  |                                                                              |  |
+ |  *------------------------------------------------------------------------------*  |
+ |                                                                                    |
+ *------------------------------------------------------------------------------------*
+*/
+
+#include "AliTPythia8.h"
+
+#include "TClonesArray.h"
+#include "TParticle.h"
+#include "TDatabasePDG.h"
+#include "TLorentzVector.h"
+
+ClassImp(AliTPythia8)
+
+AliTPythia8*  AliTPythia8::fgInstance = 0;
+
+//___________________________________________________________________________
+AliTPythia8::AliTPythia8():
+    TGenerator("AliTPythia8", "AliTPythia8"),
+    fPythia(0),
+    fNumberOfParticles(0)
+{
+   // Constructor
+   if (fgInstance) 
+      Fatal("AliTPythia8", "There's already an instance of AliTPythia8");
+  
+   delete fParticles; // was allocated as TObjArray in TGenerator
+    
+   fParticles = new TClonesArray("TParticle",50);
+   fPythia    = new Pythia8::Pythia();
+}
+
+//___________________________________________________________________________
+AliTPythia8::AliTPythia8(const char *xmlDir):
+    TGenerator("AliTPythia8", "AliTPythia8"),
+    fPythia(0),
+    fNumberOfParticles(0)
+{
+   // Constructor with an xmlDir (eg "../xmldoc"
+   if (fgInstance) 
+      Fatal("AliTPythia8", "There's already an instance of AliTPythia8");
+  
+   delete fParticles; // was allocated as TObjArray in TGenerator
+    
+   fParticles = new TClonesArray("TParticle",50);
+   fPythia    = new Pythia8::Pythia(xmlDir);
+}
+
+//___________________________________________________________________________
+AliTPythia8::~AliTPythia8()
+{
+   // Destructor
+   if (fParticles) {
+      fParticles->Delete();
+      delete fParticles;
+      fParticles = 0;
+   }
+   delete fPythia;
+}
+
+//___________________________________________________________________________
+AliTPythia8* AliTPythia8::Instance()
+{
+   // Return an instance of AliTPythia8
+   return fgInstance ? fgInstance : (fgInstance = new AliTPythia8()) ;
+}
+
+//___________________________________________________________________________
+Bool_t AliTPythia8::Initialize(Int_t idAin, Int_t idBin, Double_t ecms)
+{
+   // Initialization
+   AddParticlesToPdgDataBase();
+   return fPythia->init(idAin, idBin, ecms);
+}
+
+//___________________________________________________________________________
+void AliTPythia8::GenerateEvent()
+{
+   // Generate the next event
+   fPythia->next();
+   fNumberOfParticles  = fPythia->event.size() - 1;
+   ImportParticles();
+}
+
+//___________________________________________________________________________
+Int_t AliTPythia8::ImportParticles(TClonesArray *particles, Option_t *option)
+{
+   // Import particles from Pythia stack
+   if (particles == 0) return 0;
+   TClonesArray &clonesParticles = *particles;
+   clonesParticles.Clear();
+   Int_t nparts=0;
+   Int_t i;
+   fNumberOfParticles  = fPythia->event.size() - 1;
+
+   if (!strcmp(option,"") || !strcmp(option,"Final")) {
+      for (i = 0; i <= fNumberOfParticles; i++) {
+       if (fPythia->event[i].id() == 90) continue;
+         if (fPythia->event[i].isFinal()) {
+            new(clonesParticles[nparts]) TParticle(
+                fPythia->event[i].id(),
+                fPythia->event[i].isFinal(),
+                fPythia->event[i].mother1() - 1,
+                fPythia->event[i].mother2() - 1,
+                fPythia->event[i].daughter1() - 1, 
+                fPythia->event[i].daughter2() - 1,
+                fPythia->event[i].px(),     // [GeV/c]
+                fPythia->event[i].py(),     // [GeV/c]
+                fPythia->event[i].pz(),     // [GeV/c]
+                fPythia->event[i].e(),      // [GeV]
+                fPythia->event[i].xProd(),  // [mm]
+                fPythia->event[i].yProd(),  // [mm]
+                fPythia->event[i].zProd(),  // [mm]
+                fPythia->event[i].tProd()); // [mm/c] 
+               nparts++;
+           } // final state partice
+       } // particle loop
+    } else if (!strcmp(option,"All")) {
+       for (i = 0; i <= fNumberOfParticles; i++) {
+         if (fPythia->event[i].id() == 90) continue;
+           new(clonesParticles[nparts]) TParticle(
+               fPythia->event[i].id(),
+               fPythia->event[i].isFinal(),
+               fPythia->event[i].mother1() - 1,
+               fPythia->event[i].mother2() - 1,
+               fPythia->event[i].daughter1() - 1,
+               fPythia->event[i].daughter2() - 1,
+               fPythia->event[i].px(),       // [GeV/c]
+               fPythia->event[i].py(),       // [GeV/c]
+               fPythia->event[i].pz(),       // [GeV/c]
+               fPythia->event[i].e(),        // [GeV]
+               fPythia->event[i].xProd(),    // [mm]
+               fPythia->event[i].yProd(),    // [mm]
+               fPythia->event[i].zProd(),    // [mm]
+               fPythia->event[i].tProd());   // [mm/c]
+           nparts++;
+       } // particle loop      
+    }
+    return nparts;
+}
+
+//___________________________________________________________________________
+TObjArray* AliTPythia8::ImportParticles(Option_t* /* option */)
+{
+   // Import particles from Pythia stack
+   fParticles->Clear();
+   Int_t numpart   = fPythia->event.size() - 1;
+   TClonesArray &a = *((TClonesArray*)fParticles);
+   for (Int_t i = 1; i <= numpart; i++) {
+      new(a[i]) TParticle(
+         fPythia->event[i].id(),
+         fPythia->event[i].isFinal(),
+         fPythia->event[i].mother1()  - 1,
+         fPythia->event[i].mother2()  - 1,
+         fPythia->event[i].daughter1() - 1,
+         fPythia->event[i].daughter2() - 1,
+         fPythia->event[i].px(),       // [GeV/c]
+         fPythia->event[i].py(),       // [GeV/c]
+         fPythia->event[i].pz(),       // [GeV/c]
+         fPythia->event[i].e(),        // [GeV]
+         fPythia->event[i].xProd(),    // [mm]
+         fPythia->event[i].yProd(),    // [mm]
+         fPythia->event[i].zProd(),    // [mm]
+         fPythia->event[i].tProd());   // [mm/c]
+   }
+   return fParticles;
+}
+
+//___________________________________________________________________________
+Int_t AliTPythia8::GetN() const
+{
+   // Initialization
+   return (fPythia->event.size() - 1);
+}
+
+//___________________________________________________________________________
+void AliTPythia8::ReadString(const char* string) const
+{
+   // Configuration
+   fPythia->readString(string);
+}
+
+//___________________________________________________________________________
+void  AliTPythia8::ReadConfigFile(const char* string) const
+{
+  // Configuration
+  fPythia->readFile(string);
+}
+
+//___________________________________________________________________________
+void AliTPythia8::PrintStatistics() const
+{
+   // Print end of run statistics
+   fPythia->statistics();
+}
+
+//___________________________________________________________________________
+void AliTPythia8::EventListing() const
+{
+   // Event listing
+   fPythia->event.list();
+}
+
+//___________________________________________________________________________
+void AliTPythia8::AddParticlesToPdgDataBase()
+{
+   // Add some pythia specific particle code to the data base    
+
+   TDatabasePDG *pdgDB = TDatabasePDG::Instance();
+   pdgDB->AddParticle("string","string", 0, kTRUE,
+                      0, 0, "QCD string", 90);
+   pdgDB->AddParticle("rho_diff0", "rho_diff0", 0, kTRUE,
+                      0, 0, "QCD diffr. state", 9900110);
+   pdgDB->AddParticle("pi_diffr+", "pi_diffr+", 0, kTRUE,
+                      0, 1, "QCD diffr. state", 9900210);
+   pdgDB->AddParticle("omega_di", "omega_di", 0, kTRUE,
+                      0, 0, "QCD diffr. state", 9900220);
+   pdgDB->AddParticle("phi_diff","phi_diff", 0, kTRUE,
+                      0, 0, "QCD diffr. state", 9900330);
+   pdgDB->AddParticle("J/psi_di", "J/psi_di", 0, kTRUE,
+                      0, 0, "QCD diffr. state", 9900440);
+   pdgDB->AddParticle("n_diffr0","n_diffr0",0,kTRUE,
+                      0, 0, "QCD diffr. state", 9902110);
+   pdgDB->AddParticle("p_diffr+","p_diffr+", 0, kTRUE,
+                      0, 1, "QCD diffr. state", 9902210);
+}
+
diff --git a/PYTHIA8/AliTPythia8.h b/PYTHIA8/AliTPythia8.h
new file mode 100644 (file)
index 0000000..09f0039
--- /dev/null
@@ -0,0 +1,101 @@
+#ifndef ALITPYTHIA8_H
+#define ALITPYTHIA8_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// TPythia8                                                                   //
+//                                                                            //
+// TPythia is an interface class to C++ version of Pythia 8.1                 //
+// event generators, written by T.Sjostrand.                                  //
+////////////////////////////////////////////////////////////////////////////////
+/*
+*------------------------------------------------------------------------------------*
+ |                                                                                    |
+ |  *------------------------------------------------------------------------------*  |
+ |  |                                                                              |  |
+ |  |                                                                              |  |
+ |  |   PPP   Y   Y  TTTTT  H   H  III    A      Welcome to the Lund Monte Carlo!  |  |
+ |  |   P  P   Y Y     T    H   H   I    A A     This is PYTHIA version 8.100      |  |
+ |  |   PPP     Y      T    HHHHH   I   AAAAA    Last date of change: 20 Oct 2007  |  |
+ |  |   P       Y      T    H   H   I   A   A                                      |  |
+ |  |   P       Y      T    H   H  III  A   A    Now is 27 Oct 2007 at 18:26:53    |  |
+ |  |                                                                              |  |
+ |  |   Main author: Torbjorn Sjostrand; CERN/PH, CH-1211 Geneva, Switzerland,     |  |
+ |  |     and Department of Theoretical Physics, Lund University, Lund, Sweden;    |  |
+ |  |     phone: + 41 - 22 - 767 82 27; e-mail: torbjorn@thep.lu.se                |  |
+ |  |   Author: Stephen Mrenna; Computing Division, Simulations Group,             |  |
+ |  |     Fermi National Accelerator Laboratory, MS 234, Batavia, IL 60510, USA;   |  |
+ |  |     phone: + 1 - 630 - 840 - 2556; e-mail: mrenna@fnal.gov                   |  |
+ |  |   Author: Peter Skands; CERN/PH, CH-1211 Geneva, Switzerland,                |  |
+ |  |     and Theoretical Physics Department,                                      |  |
+ |  |     Fermi National Accelerator Laboratory, MS 106, Batavia, IL 60510, USA;   |  |
+ |  |     phone: + 41 - 22 - 767 24 59; e-mail: skands@fnal.gov                    |  |
+ |  |                                                                              |  |
+ |  |   The main program reference is the 'Brief Introduction to PYTHIA 8.1',      |  |
+ |  |   T. Sjostrand, S. Mrenna and P. Skands, arXiv:0710.3820                     |  |
+ |  |                                                                              |  |
+ |  |   The main physics reference is the 'PYTHIA 6.4 Physics and Manual',         |  |
+ |  |   T. Sjostrand, S. Mrenna and P. Skands, JHEP05 (2006) 026 [hep-ph/0603175]. |  |
+ |  |                                                                              |  |
+ |  |   An archive of program versions and documentation is found on the web:      |  |
+ |  |   http://www.thep.lu.se/~torbjorn/Pythia.html                                |  |
+ |  |                                                                              |  |
+ |  |   This program is released under the GNU General Public Licence version 2.   |  |
+ |  |   Please respect the MCnet Guidelines for Event Generator Authors and Users. |  |
+ |  |                                                                              |  |
+ |  |   Disclaimer: this program comes without any guarantees.                     |  |
+ |  |   Beware of errors and use common sense when interpreting results.           |  |
+ |  |                                                                              |  |
+ |  |   Copyright (C) 2007 Torbjorn Sjostrand                                      |  |
+ |  |                                                                              |  |
+ |  |                                                                              |  |
+ |  *------------------------------------------------------------------------------*  |
+ |                                                                                    |
+ *------------------------------------------------------------------------------------*
+*/
+
+#include "TGenerator.h"
+#include "Pythia.h"
+
+
+class TClonesArray;
+class TObjArray;
+
+class AliTPythia8 : public TGenerator
+{
+public:
+   AliTPythia8();
+   AliTPythia8(const char *xmlDir);
+   virtual ~AliTPythia8();
+   static AliTPythia8     *Instance();
+   Pythia8::Pythia        *Pythia8() {return fPythia;}
+
+   // Interface
+   virtual void            GenerateEvent();
+   virtual Int_t           ImportParticles(TClonesArray *particles, Option_t *option="");
+   virtual TObjArray      *ImportParticles(Option_t *option="");
+
+   // Others
+   void                    ReadString(const char* string) const;
+   void                    ReadConfigFile(const char* string) const;
+   Bool_t                  Initialize(Int_t idAin, Int_t idBin, Double_t ecms);
+   void                    PrintStatistics() const;
+   void                    EventListing() const;
+   Int_t                   GetN() const;
+
+protected:
+   static  AliTPythia8     *fgInstance;             //! singleton instance
+   Pythia8::Pythia         *fPythia;                //! The pythia8 instance
+   Int_t                    fNumberOfParticles;     //! Number of particles
+private:
+   void                    AddParticlesToPdgDataBase();
+   ClassDef(AliTPythia8, 1)   // Interface class of Pythia8
+};
+
+#endif
+
index ab6c42b..642eb4b 100644 (file)
@@ -1,4 +1,4 @@
-SRCS= AliPythia8.cxx AliDecayerPythia8.cxx
+SRCS= AliTPythia8.cxx AliPythia8.cxx AliDecayerPythia8.cxx
 HDRS:= $(SRCS:.cxx=.h) 
 DHDR:= AliPythia8LinkDef.h     
-EINCLUDE:= $(PYTHIA8)/include PYTHIA6
+EINCLUDE:= PYTHIA8/pythia8140/include PYTHIA6
index aba88f2..7deb933 100644 (file)
@@ -1,51 +1,54 @@
 #-*- Mode: Makefile -*-
-
 SRCS:= \
-pythia8130/src/Analysis.cxx \
-pythia8130/src/Basics.cxx \
-pythia8130/src/BeamParticle.cxx \
-pythia8130/src/BeamRemnants.cxx \
-pythia8130/src/BeamShape.cxx \
-pythia8130/src/BoseEinstein.cxx \
-pythia8130/src/Event.cxx \
-pythia8130/src/FragmentationFlavZpT.cxx \
-pythia8130/src/FragmentationSystems.cxx \
-pythia8130/src/HadronLevel.cxx \
-pythia8130/src/Info.cxx \
-pythia8130/src/LesHouches.cxx \
-pythia8130/src/MiniStringFragmentation.cxx \
-pythia8130/src/MultipleInteractions.cxx \
-pythia8130/src/ParticleData.cxx \
-pythia8130/src/ParticleDecays.cxx \
-pythia8130/src/PartonDistributions.cxx \
-pythia8130/src/PartonLevel.cxx \
-pythia8130/src/PhaseSpace.cxx \
-pythia8130/src/ProcessContainer.cxx \
-pythia8130/src/ProcessLevel.cxx \
-pythia8130/src/Pythia.cxx \
-pythia8130/src/ResonanceDecays.cxx \
-pythia8130/src/ResonanceWidths.cxx \
-pythia8130/src/Settings.cxx \
-pythia8130/src/SigmaCompositeness.cxx \
-pythia8130/src/SigmaEW.cxx \
-pythia8130/src/SigmaExtraDim.cxx \
-pythia8130/src/SigmaHiggs.cxx \
-pythia8130/src/SigmaLeftRightSym.cxx \
-pythia8130/src/SigmaLeptoquark.cxx \
-pythia8130/src/SigmaNewGaugeBosons.cxx \
-pythia8130/src/SigmaOnia.cxx \
-pythia8130/src/SigmaProcess.cxx \
-pythia8130/src/SigmaQCD.cxx \
-pythia8130/src/SigmaSUSY.cxx \
-pythia8130/src/SigmaTotal.cxx \
-pythia8130/src/SpaceShower.cxx \
-pythia8130/src/StandardModel.cxx \
-pythia8130/src/StringFragmentation.cxx \
-pythia8130/src/SusyLesHouches.cxx \
-pythia8130/src/TimeShower.cxx \
-pythia8130/src/UserHooks.cxx
+pythia8140/src/Analysis.cxx \
+pythia8140/src/Basics.cxx \
+pythia8140/src/BeamParticle.cxx \
+pythia8140/src/BeamRemnants.cxx \
+pythia8140/src/BeamShape.cxx \
+pythia8140/src/BoseEinstein.cxx \
+pythia8140/src/Event.cxx \
+pythia8140/src/FragmentationFlavZpT.cxx \
+pythia8140/src/FragmentationSystems.cxx \
+pythia8140/src/HadronLevel.cxx \
+pythia8140/src/Info.cxx \
+pythia8140/src/LesHouches.cxx \
+pythia8140/src/MiniStringFragmentation.cxx \
+pythia8140/src/MultipleInteractions.cxx \
+pythia8140/src/ParticleData.cxx \
+pythia8140/src/ParticleDecays.cxx \
+pythia8140/src/PartonDistributions.cxx \
+pythia8140/src/PartonLevel.cxx \
+pythia8140/src/PartonSystems.cxx \
+pythia8140/src/PhaseSpace.cxx \
+pythia8140/src/ProcessContainer.cxx \
+pythia8140/src/ProcessLevel.cxx \
+pythia8140/src/Pythia.cxx \
+pythia8140/src/PythiaStdlib.cxx \
+pythia8140/src/ResonanceDecays.cxx \
+pythia8140/src/ResonanceWidths.cxx \
+pythia8140/src/Settings.cxx \
+pythia8140/src/SigmaCompositeness.cxx \
+pythia8140/src/SigmaEW.cxx \
+pythia8140/src/SigmaExtraDim.cxx \
+pythia8140/src/SigmaGeneric.cxx \
+pythia8140/src/SigmaHiggs.cxx \
+pythia8140/src/SigmaLeftRightSym.cxx \
+pythia8140/src/SigmaLeptoquark.cxx \
+pythia8140/src/SigmaNewGaugeBosons.cxx \
+pythia8140/src/SigmaOnia.cxx \
+pythia8140/src/SigmaProcess.cxx \
+pythia8140/src/SigmaQCD.cxx \
+pythia8140/src/SigmaSUSY.cxx \
+pythia8140/src/SigmaTotal.cxx \
+pythia8140/src/SpaceShower.cxx \
+pythia8140/src/StandardModel.cxx \
+pythia8140/src/StringFragmentation.cxx \
+pythia8140/src/SusyCouplings.cxx \
+pythia8140/src/SusyLesHouches.cxx \
+pythia8140/src/TimeShower.cxx \
+pythia8140/src/UserHooks.cxx
 
-EINCLUDE:= PYTHIA8/pythia8130/include
+EINCLUDE:= PYTHIA8/pythia8140/include
 ifeq (macosxicc,$(ALICE_TARGET))
 PACKFFLAGS      := $(filter-out -O%,$(FFLAGS))
 endif
index 267d5b7..3cf6799 100644 (file)
@@ -8,7 +8,6 @@ void pythia8(Int_t nev = 1, char* filename = "galice.root")
     gSystem->Load("libpythia6.so");   
     gSystem->Load("libAliPythia6.so");
     gSystem->Load("libpythia8.so");   
-    gSystem->Load("libEGPythia8.so"); 
     gSystem->Load("libAliPythia8.so");
     
     AliRunLoader* rl = AliRunLoader::Open("galice.root","FASTRUN","recreate");
diff --git a/PYTHIA8/pythia8140/include/Analysis.h b/PYTHIA8/pythia8140/include/Analysis.h
new file mode 100644 (file)
index 0000000..b1d4c9b
--- /dev/null
@@ -0,0 +1,353 @@
+// Analysis.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for the Sphericity, Thrust, ClusterJet and CellJet classes.
+// Sphericity: sphericity analysis of the event.
+// Thrust: thrust analysis of the event.
+// ClusterJet: clustering jet finder.
+// CellJet: calorimetric cone jet finder. 
+
+#ifndef Pythia8_Analysis_H
+#define Pythia8_Analysis_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Sphericity class.
+// This class performs (optionally modified) sphericity analysis on an event.
+
+class Sphericity {
+
+public: 
+
+  // Constructor.
+  Sphericity(double powerIn = 2., int selectIn = 2) : power(powerIn), 
+    select(selectIn), nFew(0), nBack(0) {powerInt = 0; 
+    if (abs(power - 1.) < 0.01) powerInt = 1;
+    if (abs(power - 2.) < 0.01) powerInt = 2; 
+    powerMod = 0.5 * power - 1.;}
+  
+  // Analyze event.
+  bool analyze(const Event& event, ostream& os = cout);
+
+  // Return info on results of analysis.
+  double sphericity()      const {return 1.5 * (eVal2 + eVal3);}
+  double aplanarity()      const {return 1.5 * eVal3;}
+  double eigenValue(int i) const {return (i < 2) ? eVal1 :
+    ( (i < 3) ? eVal2 : eVal3 ) ;}
+  Vec4 eventAxis(int i)    const {return (i < 2) ? eVec1 :
+    ( (i < 3) ? eVec2 : eVec3 ) ;}
+
+  // Provide a listing of the info.
+  void list(ostream& os = cout) const;
+
+  // Tell how many events could not be analyzed.
+  int nError() const {return nFew + nBack;}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NSTUDYMIN, TIMESTOPRINT;
+  static const double P2MIN, EIGENVALUEMIN;
+
+  // Properties of analysis.
+  double power;
+  int    select, powerInt; 
+  double powerMod;
+
+  // Outcome of analysis.
+  double eVal1, eVal2, eVal3; 
+  Vec4   eVec1, eVec2, eVec3; 
+
+  // Error statistics;
+  int    nFew, nBack;
+
+};  
+
+//==========================================================================
+
+// Thrust class.
+// This class performs thrust analysis on an event.
+
+class Thrust {
+
+public: 
+
+  // Constructor.
+  Thrust(int selectIn = 2) : select(selectIn), nFew(0) {}
+  
+  // Analyze event.
+  bool analyze(const Event& event, ostream& os = cout);
+
+  // Return info on results of analysis.
+  double thrust()       const {return eVal1;}
+  double tMajor()       const {return eVal2;}
+  double tMinor()       const {return eVal3;}
+  double oblateness()   const {return eVal2 - eVal3;}
+  Vec4 eventAxis(int i) const {return (i < 2) ? eVec1 :
+    ( (i < 3) ? eVec2 : eVec3 ) ;}
+
+  // Provide a listing of the info.
+  void list(ostream& os = cout) const;
+
+  // Tell how many events could not be analyzed.
+  int nError() const {return nFew;}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NSTUDYMIN, TIMESTOPRINT;
+  static const double MAJORMIN;
+
+  // Properties of analysis.
+  int    select; 
+
+  // Outcome of analysis.
+  double eVal1, eVal2, eVal3; 
+  Vec4   eVec1, eVec2, eVec3; 
+
+  // Error statistics;
+  int    nFew;
+
+};  
+
+//==========================================================================
+
+// SingleClusterJet class.
+// Simple helper class to ClusterJet for a jet and its contents. 
+
+class SingleClusterJet {
+
+public:
+
+  // Constructors.
+  SingleClusterJet(Vec4 pJetIn = 0., int motherIn = 0) : 
+    pJet(pJetIn), mother(motherIn), daughter(0), multiplicity(1),    
+    isAssigned(false) {pAbs = max( PABSMIN, pJet.pAbs());}
+  SingleClusterJet& operator=(const SingleClusterJet& j) { if (this != &j)
+    { pJet = j.pJet;  mother = j.mother; daughter = j.daughter; 
+    multiplicity = j.multiplicity; pAbs = j.pAbs;
+    isAssigned = j.isAssigned;} return *this; }
+
+  // Properties of jet.
+  // Note: mother, daughter and isAssigned only used for original 
+  // particles, multiplicity and pTemp only for reconstructed jets.
+  Vec4   pJet; 
+  int    mother, daughter, multiplicity;
+  bool   isAssigned;
+  double pAbs; 
+  Vec4   pTemp; 
+
+  // Distance measures (Lund, JADE, Durham) with friend.
+  friend double dist2Fun(int measure, const SingleClusterJet& j1, 
+    const SingleClusterJet& j2);  
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const double PABSMIN;
+
+} ;
+
+//==========================================================================
+
+// ClusterJet class.
+// This class performs a jet clustering according to different
+// distance measures: Lund, JADE or Durham.
+
+class ClusterJet {
+
+public: 
+
+  // Constructor.
+  ClusterJet(string measureIn = "Lund", int selectIn = 2, int massSetIn = 2, 
+    bool preclusterIn = false, bool reassignIn = false) : measure(1), 
+    select(selectIn), massSet(massSetIn), doPrecluster(preclusterIn), 
+    doReassign(reassignIn), nFew(0) {
+    char firstChar = toupper(measureIn[0]);
+    if (firstChar == 'J') measure = 2;
+    if (firstChar == 'D') measure = 3; 
+  }
+      
+  // Analyze event.
+  bool analyze(const Event& event, double yScaleIn, double pTscaleIn, 
+    int nJetMinIn = 1, int nJetMaxIn = 0, ostream& os = cout);
+
+  // Return info on jets produced.
+  int    size() const {return jets.size();}
+  Vec4 p(int i) const {return jets[i].pJet;}
+
+  // Return belonging of particle to one of the jets (-1 if none).
+  int jetAssignment(int i) const {
+    for (int iP = 0; iP < int(particles.size()); ++iP)
+    if (particles[iP].mother == i) return particles[iP].daughter;
+    return -1;} 
+
+  // Provide a listing of the info.
+  void list(ostream& os = cout) const;
+
+  // Return info on clustering values.
+  int    distanceSize() const {return distances.size();}
+  double distance(int i) const {
+    return (i < distanceSize()) ? distances[i] : 0.; }
+
+  // Tell how many events could not be analyzed.
+  int nError() const {return nFew;}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    TIMESTOPRINT;
+  static const double PIMASS, PABSMIN, PRECLUSTERFRAC, PRECLUSTERSTEP;
+
+  // Properties of analysis.
+  int    measure, select, massSet; 
+  bool   doPrecluster, doReassign;
+  double yScale, pTscale;
+  int    nJetMin, nJetMax; 
+
+  // Temporary results.
+  double piMass, dist2Join, dist2BigMin, distPre, dist2Pre;
+  vector<SingleClusterJet> particles;
+  int    nParticles;
+
+  // Error statistics;
+  int    nFew;
+
+  // Member functions for some operations (for clarity).
+  void precluster();
+  void reassign();
+
+  // Outcome of analysis: ET-ordered list of jets. 
+  vector<SingleClusterJet> jets;
+
+  // Outcome of analysis: the distance values where the jets were merged.
+  deque<double> distances;
+
+};  
+
+//==========================================================================
+
+// SingleCell class.
+// Simple helper class to CellJet for a cell and its contents. 
+
+class SingleCell {
+
+public:
+
+  // Constructor.
+  SingleCell(int iCellIn = 0, double etaCellIn = 0., double phiCellIn = 0., 
+    double eTcellIn = 0., int multiplicityIn = 0) : iCell(iCellIn), 
+    etaCell(etaCellIn), phiCell(phiCellIn), eTcell(eTcellIn), 
+    multiplicity(multiplicityIn), canBeSeed(true), isUsed(false),
+    isAssigned(false) {}
+
+  // Properties of cell.
+  int    iCell;
+  double etaCell, phiCell, eTcell;
+  int    multiplicity;
+  bool   canBeSeed, isUsed, isAssigned;
+
+} ;
+
+//==========================================================================
+
+// SingleCellJet class.
+// Simple helper class to CellJet for a jet and its contents. 
+
+class SingleCellJet {
+
+public:
+
+  // Constructor.
+  SingleCellJet(double eTjetIn = 0., double etaCenterIn = 0., 
+    double phiCenterIn = 0., double etaWeightedIn = 0.,
+    double phiWeightedIn = 0., int multiplicityIn = 0,
+    Vec4 pMassiveIn = 0.) : eTjet(eTjetIn), etaCenter(etaCenterIn), 
+    phiCenter(phiCenterIn), etaWeighted(etaWeightedIn), 
+    phiWeighted(phiWeightedIn), multiplicity(multiplicityIn),
+    pMassive(pMassiveIn) {}
+
+  // Properties of jet.
+  double eTjet, etaCenter, phiCenter, etaWeighted, phiWeighted;
+  int    multiplicity;
+  Vec4   pMassive;  
+
+} ;
+
+//==========================================================================
+
+// CellJet class.
+// This class performs a cone jet search in (eta, phi, E_T) space.
+
+class CellJet {
+
+public: 
+
+  // Constructor.
+  CellJet(double etaMaxIn = 5., int nEtaIn = 50, int nPhiIn = 32, 
+    int selectIn = 2, int smearIn = 0, double resolutionIn = 0.5, 
+    double upperCutIn = 2., double thresholdIn = 0., Rndm* rndmPtrIn = 0) 
+    : etaMax(etaMaxIn), nEta(nEtaIn), nPhi(nPhiIn), select(selectIn), 
+    smear(smearIn), resolution(resolutionIn), upperCut(upperCutIn), 
+    threshold(thresholdIn), nFew(0), rndmPtr(rndmPtrIn) { }
+  
+  // Analyze event.
+  bool analyze(const Event& event, double eTjetMinIn = 20., 
+    double coneRadiusIn = 0.7, double eTseedIn = 1.5, ostream& os = cout);
+
+  // Return info on results of analysis.
+  int    size()              const {return jets.size();}
+  double eT(int i)           const {return jets[i].eTjet;}
+  double etaCenter(int i)    const {return jets[i].etaCenter;}
+  double phiCenter(int i)    const {return jets[i].phiCenter;}
+  double etaWeighted(int i)  const {return jets[i].etaWeighted;}
+  double phiWeighted(int i)  const {return jets[i].phiWeighted;}
+  int    multiplicity(int i) const {return jets[i].multiplicity;}
+  Vec4   pMassless(int i)    const {return jets[i].eTjet * Vec4(
+           cos(jets[i].phiWeighted),  sin(jets[i].phiWeighted),
+          sinh(jets[i].etaWeighted), cosh(jets[i].etaWeighted) );}
+  Vec4   pMassive(int i)     const {return jets[i].pMassive;}
+  double m(int i)            const {return jets[i].pMassive.mCalc();}
+
+  // Provide a listing of the info.
+  void list(ostream& os = cout) const;
+
+  // Tell how many events could not be analyzed: so far never.
+  int nError() const {return nFew;}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    TIMESTOPRINT;
+
+  // Properties of analysis.
+  double etaMax; 
+  int    nEta, nPhi, select, smear;
+  double resolution, upperCut, threshold;
+  double eTjetMin, coneRadius, eTseed; 
+
+  // Error statistics;
+  int    nFew;
+
+  // Outcome of analysis: ET-ordered list of jets. 
+  vector<SingleCellJet> jets;
+
+  // Pointer to the random number generator (needed for energy smearing).
+  Rndm* rndmPtr;
+
+};  
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // end Pythia8_Analysis_H
+
diff --git a/PYTHIA8/pythia8140/include/Basics.h b/PYTHIA8/pythia8140/include/Basics.h
new file mode 100644 (file)
index 0000000..c35338c
--- /dev/null
@@ -0,0 +1,404 @@
+// Basics.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for basic, often-used helper classes.
+// RndmEngine: base class for external random number generators.
+// Rndm: random number generator.
+// Vec4: simple four-vectors.
+// RotBstMatrix: matrices encoding rotations and boosts of Vec4 objects.
+// Hist: simple one-dimensional histograms.
+
+#ifndef Pythia8_Basics_H
+#define Pythia8_Basics_H
+
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// RndmEngine is the base class for external random number generators.
+// There is only one pure virtual method, that should do the generation. 
+
+class RndmEngine {
+
+public:
+
+  // A pure virtual method, wherein the derived class method 
+  // generates a random number uniformly distributed between 1 and 1.
+  virtual double flat() = 0;
+
+protected:
+
+  // Destructor.
+  virtual ~RndmEngine() {}
+
+}; 
+
+//==========================================================================
+
+// Rndm class.
+// This class handles random number generation according to the
+// Marsaglia-Zaman-Tsang algorithm.
+
+class Rndm {
+
+public:
+
+  // Constructors.
+  Rndm() : initRndm(false), seedSave(0), sequence(0), 
+    useExternalRndm(false), rndmEngPtr(0) { } 
+  Rndm(int seedIn) : initRndm(false), seedSave(0), sequence(0), 
+    useExternalRndm(false), rndmEngPtr(0) { init(seedIn);} 
+
+  // Possibility to pass in pointer for external random number generation.
+  bool rndmEnginePtr( RndmEngine* rndmEngPtrIn);  
+
+  // Initialize, normally at construction or in first call.
+  void init(int seedIn = 0) ;
+
+  // Generate next random number uniformly between 0 and 1.
+  double flat() ;
+
+  // Generate random numbers according to exp(-x).
+  double exp() { return -log(flat()) ;} 
+
+  // Generate random numbers according to x * exp(-x).
+  double xexp() { return -log(flat() * flat()) ;} 
+
+  // Generate random numbers according to exp(-x^2/2).
+  double gauss() {return sqrt(-2. * log(flat())) * cos(M_PI * flat());}
+
+  // Generate two random numbers according to exp(-x^2/2-y^2/2).
+  pair<double, double> gauss2() {double r = sqrt(-2. * log(flat()));
+    double phi = 2. * M_PI * flat(); 
+    return pair<double, double>(r * sin(phi), r * cos(phi));}
+
+  // Pick one option among  vector of (positive) probabilities.
+  int pick(const vector<double>& prob) ; 
+
+  // Save or read current state to or from a binary file.
+  bool dumpState(string fileName);
+  bool readState(string fileName);
+
+private:
+
+  // Default random number sequence.
+  static const int DEFAULTSEED;
+
+  // State of the random number generator.
+  bool   initRndm; 
+  int    i97, j97, defaultSeed, seedSave;
+  long   sequence;
+  double u[97], c, cd, cm;
+
+  // Pointer for external random number generation.
+  bool   useExternalRndm; 
+  RndmEngine* rndmEngPtr;
+
+};
+
+//==========================================================================
+
+// Forward reference to RotBstMatrix class.
+class RotBstMatrix;
+
+//==========================================================================
+
+// Vec4 class.
+// This class implements four-vectors, in energy-momentum space.
+// (But can equally well be used to hold space-time four-vectors.)
+
+class Vec4 {
+
+public:
+
+  // Constructors.
+  Vec4(double xIn = 0., double yIn = 0., double zIn = 0., double tIn = 0.)
+    : xx(xIn), yy(yIn), zz(zIn), tt(tIn) { }
+  Vec4(const Vec4& v) : xx(v.xx), yy(v.yy), zz(v.zz), tt(v.tt) { }
+  Vec4& operator=(const Vec4& v) { if (this != &v) { xx = v.xx; yy = v.yy; 
+    zz = v.zz; tt = v.tt; } return *this; }
+  Vec4& operator=(double value) { xx = value; yy = value; zz = value; 
+    tt = value; return *this; }
+      
+  // Member functions for input.
+  void reset() {xx = 0.; yy = 0.; zz = 0.; tt = 0.;}
+  void p(double xIn, double yIn, double zIn, double tIn) 
+    {xx = xIn; yy = yIn; zz = zIn; tt = tIn;}
+  void p(Vec4 pIn) {xx = pIn.xx; yy = pIn.yy; zz = pIn.zz; tt = pIn.tt;} 
+  void px(double xIn) {xx = xIn;}
+  void py(double yIn) {yy = yIn;}
+  void pz(double zIn) {zz = zIn;}
+  void e(double tIn) {tt = tIn;}
+
+  // Member functions for output.
+  double px() const {return xx;}
+  double py() const {return yy;}
+  double pz() const {return zz;}
+  double e() const {return tt;}
+  double mCalc() const {double temp = tt*tt - xx*xx - yy*yy - zz*zz;
+    return (temp >= 0.) ? sqrt(temp) : -sqrt(-temp);}
+  double m2Calc() const {return tt*tt - xx*xx - yy*yy - zz*zz;}
+  double pT() const {return sqrt(xx*xx + yy*yy);}
+  double pT2() const {return xx*xx + yy*yy;}
+  double pAbs() const {return sqrt(xx*xx + yy*yy + zz*zz);}
+  double pAbs2() const {return xx*xx + yy*yy + zz*zz;}
+  double eT() const {double temp = xx*xx + yy*yy;
+    return tt * sqrt( temp / (temp + zz*zz) );}
+  double eT2() const {double temp = xx*xx + yy*yy;
+    return tt*tt * temp / (temp + zz*zz);}
+  double theta() const {return atan2(sqrt(xx*xx + yy*yy), zz);}
+  double phi() const {return atan2(yy,xx);}
+  double thetaXZ() const {return atan2(xx,zz);}
+  double pPos() const {return tt + zz;}
+  double pNeg() const {return tt - zz;}
+
+  // Member functions that perform operations.
+  void rescale3(double fac) {xx *= fac; yy *= fac; zz *= fac;}
+  void rescale4(double fac) {xx *= fac; yy *= fac; zz *= fac; tt *= fac;}
+  void flip3() {xx = -xx; yy = -yy; zz = -zz;}
+  void flip4() {xx = -xx; yy = -yy; zz = -zz; tt = -tt;}
+  void rot(double thetaIn, double phiIn); 
+  void rotaxis(double phiIn, double nx, double ny, double nz); 
+  void rotaxis(double phiIn, const Vec4& n);
+  void bst(double betaX, double betaY, double betaZ); 
+  void bst(double betaX, double betaY, double betaZ, double gamma); 
+  void bst(const Vec4& pIn); 
+  void bst(const Vec4& pIn, double mIn); 
+  void bstback(const Vec4& pIn); 
+  void bstback(const Vec4& pIn, double mIn); 
+  void rotbst(const RotBstMatrix& M); 
+
+  // Operator overloading with member functions
+  Vec4 operator-() {Vec4 tmp; tmp.xx = -xx; tmp.yy = -yy; tmp.zz = -zz; 
+    tmp.tt = -tt; return tmp;}
+  Vec4& operator+=(const Vec4& v) {xx += v.xx; yy += v.yy; zz += v.zz; 
+    tt += v.tt; return *this;}
+  Vec4& operator-=(const Vec4& v) {xx -= v.xx; yy -= v.yy; zz -= v.zz; 
+    tt -= v.tt; return *this;}
+  Vec4& operator*=(double f) {xx *= f; yy *= f; zz *= f; 
+    tt *= f; return *this;}
+  Vec4& operator/=(double f) {xx /= f; yy /= f; zz /= f; 
+    tt /= f; return *this;}
+
+  // Operator overloading with friends
+  friend Vec4 operator+(const Vec4& v1, const Vec4& v2);
+  friend Vec4 operator-(const Vec4& v1, const Vec4& v2);
+  friend Vec4 operator*(double f, const Vec4& v1);
+  friend Vec4 operator*(const Vec4& v1, double f);
+  friend Vec4 operator/(const Vec4& v1, double f);
+  friend double operator*(const Vec4& v1, const Vec4& v2);
+
+  // Invariant mass of a pair and its square.
+  friend double m(const Vec4& v1, const Vec4& v2);
+  friend double m2(const Vec4& v1, const Vec4& v2);
+
+  // Scalar and cross product of 3-vector parts.
+  friend double dot3(const Vec4& v1, const Vec4& v2);
+  friend Vec4 cross3(const Vec4& v1, const Vec4& v2);
+
+  // theta is polar angle between v1 and v2.
+  friend double theta(const Vec4& v1, const Vec4& v2);
+  friend double costheta(const Vec4& v1, const Vec4& v2);
+
+  // phi is azimuthal angle between v1 and v2 around z axis.
+  friend double phi(const Vec4& v1, const Vec4& v2);  
+  friend double cosphi(const Vec4& v1, const Vec4& v2);
+
+  // phi is azimuthal angle between v1 and v2 around n axis.
+  friend double phi(const Vec4& v1, const Vec4& v2, const Vec4& n);
+  friend double cosphi(const Vec4& v1, const Vec4& v2, const Vec4& n);
+
+  // Print a four-vector
+  friend ostream& operator<<(ostream&, const Vec4& v) ;
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double TINY;
+
+  // The four-vector data members.
+  double xx, yy, zz, tt;
+
+};
+
+// Implementation of operator overloading with friends.
+
+inline Vec4 operator+(const Vec4& v1, const Vec4& v2) 
+  {Vec4 v = v1 ; return v += v2;}
+
+inline Vec4 operator-(const Vec4& v1, const Vec4& v2) 
+  {Vec4 v = v1 ; return v -= v2;}
+
+inline Vec4 operator*(double f, const Vec4& v1) 
+  {Vec4 v = v1; return v *= f;}
+
+inline Vec4 operator*(const Vec4& v1, double f) 
+  {Vec4 v = v1; return v *= f;}
+
+inline Vec4 operator/(const Vec4& v1, double f) 
+  {Vec4 v = v1; return v /= f;}
+
+inline double operator*(const Vec4& v1, const Vec4& v2)
+  {return v1.tt*v2.tt - v1.xx*v2.xx - v1.yy*v2.yy - v1.zz*v2.zz;}  
+
+//==========================================================================
+
+// RotBstMatrix class.
+// This class implements 4 * 4 matrices that encode an arbitrary combination
+// of rotations and boosts, that can be applied to Vec4 four-vectors.
+
+class RotBstMatrix {
+
+public:
+
+  // Constructors.
+  RotBstMatrix() {for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) 
+    { M[i][j] = (i==j) ? 1. : 0.; } } } 
+  RotBstMatrix(const RotBstMatrix& Min) {
+    for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) {
+    M[i][j] = Min.M[i][j]; } } }
+  RotBstMatrix& operator=(const RotBstMatrix& Min) {if (this != &Min) {
+    for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) {
+    M[i][j] = Min.M[i][j]; } } } return *this; }
+
+  // Member functions.
+  void rot(double = 0., double = 0.);
+  void rot(const Vec4& p);
+  void bst(double = 0., double = 0., double = 0.);
+  void bst(const Vec4&);
+  void bstback(const Vec4&);
+  void bst(const Vec4&, const Vec4&);
+  void toCMframe(const Vec4&, const Vec4&);
+  void fromCMframe(const Vec4&, const Vec4&);
+  void rotbst(const RotBstMatrix&);
+  void invert();
+  void reset();
+
+  // Crude estimate deviation from unit matrix.
+  double deviation() const;
+
+  // Print a transformation matrix.
+  friend ostream& operator<<(ostream&, const RotBstMatrix&) ;
+
+  // Private members to be accessible from Vec4. 
+  friend class Vec4;
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double TINY;
+
+  // The rotation-and-boost matrix data members.
+  double M[4][4];
+
+};
+
+//==========================================================================
+
+// Hist class.
+// This class handles a single histogram at a time.
+
+class Hist{
+
+public:
+
+  // Constructors, including copy constructors.
+  Hist() {;}
+  Hist(string titleIn, int nBinIn = 100, double xMinIn = 0., 
+    double xMaxIn = 1.) {
+    book(titleIn, nBinIn, xMinIn, xMaxIn);} 
+  Hist(const Hist& h) 
+    : title(h.title), nBin(h.nBin), nFill(h.nFill), xMin(h.xMin), 
+    xMax(h.xMax), dx(h.dx), under(h.under), inside(h.inside), 
+    over(h.over), res(h.res) { }    
+  Hist(string titleIn, const Hist& h) 
+    : title(titleIn), nBin(h.nBin), nFill(h.nFill), xMin(h.xMin), 
+    xMax(h.xMax), dx(h.dx), under(h.under), inside(h.inside), 
+    over(h.over), res(h.res) { }         
+  Hist& operator=(const Hist& h) { if(this != &h) {
+    nBin = h.nBin; nFill = h.nFill; xMin = h.xMin; xMax = h.xMax; 
+    dx = h.dx;  under = h.under; inside = h.inside; over = h.over; 
+    res = h.res; } return *this; }    
+  
+  // Book a histogram.
+  void book(string titleIn = "  ", int nBinIn = 100, double xMinIn = 0., 
+    double xMaxIn = 1.) ; 
+  // Set title of a histogram.
+  void name(string titleIn = "  ") {title = titleIn; }  
+
+  // Reset bin contents.
+  void null() ; 
+
+  // Fill bin with weight.
+  void fill(double x, double w = 1.) ;
+
+  // Print a histogram with overloaded << operator.
+  friend ostream& operator<<(ostream& os, const Hist& h) ;
+
+  // Print histogram contents as a table (e.g. for Gnuplot).
+  void table(ostream& os = cout) const ;
+  void table(string fileName) const {
+    ofstream streamName(fileName.c_str()); table(streamName); }
+
+
+  // Return content of specific bin: -1 gives underflow and nBin overflow.
+  double getBinContent(int iBin) ;
+
+  // Return number of entries
+  int getEntries() {return nFill; }
+
+  // Check whether another histogram has same size and limits.
+  bool sameSize(const Hist& h) const ;
+
+  // Take logarithm (base 10 or e) of bin contents.
+  void takeLog(bool tenLog = true) ;
+
+  // Operator overloading with member functions
+  Hist& operator+=(const Hist& h) ; 
+  Hist& operator-=(const Hist& h) ;
+  Hist& operator*=(const Hist& h) ; 
+  Hist& operator/=(const Hist& h) ;
+  Hist& operator+=(double f) ; 
+  Hist& operator-=(double f) ; 
+  Hist& operator*=(double f) ; 
+  Hist& operator/=(double f) ; 
+
+  // Operator overloading with friends
+  friend Hist operator+(double f, const Hist& h1);
+  friend Hist operator+(const Hist& h1, double f);
+  friend Hist operator+(const Hist& h1, const Hist& h2);
+  friend Hist operator-(double f, const Hist& h1);
+  friend Hist operator-(const Hist& h1, double f);
+  friend Hist operator-(const Hist& h1, const Hist& h2);
+  friend Hist operator*(double f, const Hist& h1);
+  friend Hist operator*(const Hist& h1, double f);
+  friend Hist operator*(const Hist& h1, const Hist& h2);
+  friend Hist operator/(double f, const Hist& h1);
+  friend Hist operator/(const Hist& h1, double f);
+  friend Hist operator/(const Hist& h1, const Hist& h2);
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    NBINMAX, NCOLMAX, NLINES;
+  static const double TOLERANCE, TINY, SMALLFRAC, DYAC[];
+  static const char   NUMBER[];
+
+  // Properties and contents of a histogram.
+  string title;
+  int    nBin, nFill; 
+  double xMin, xMax, dx, under, inside, over; 
+  vector<double> res;
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // end Pythia8_Basics_H
diff --git a/PYTHIA8/pythia8140/include/BeamParticle.h b/PYTHIA8/pythia8140/include/BeamParticle.h
new file mode 100644 (file)
index 0000000..947e7c9
--- /dev/null
@@ -0,0 +1,305 @@
+// BeamParticle.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for information on incoming beams.
+// ResolvedParton: an initiator or remnant in beam.
+// BeamParticle: contains partons, parton densities, etc.
+
+#ifndef Pythia8_BeamParticle_H
+#define Pythia8_BeamParticle_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// This class holds info on a parton resolved inside the incoming beam,
+// i.e. either an initiator (part of a hard or a multiple interaction)
+// or a remnant (part of the beam remnant treatment).
+
+// The companion code is -1 from onset and for g, is -2 for an unmatched 
+// sea quark, is >= 0 for a matched sea quark, with the number giving the 
+// companion position, and is -3 for a valence quark.
+
+// Rescattering partons properly do not belong here, but bookkeeping is
+// simpler with them, so they are stored with companion code -10.
+
+class ResolvedParton {
+
+public:
+
+  // Constructor.
+  ResolvedParton( int iPosIn = 0, int idIn = 0, double xIn = 0., 
+    int companionIn = -1) : iPosRes(iPosIn), idRes(idIn), xRes(xIn), 
+    companionRes(companionIn), xqCompRes(0.), mRes(0.), factorRes(1.), 
+    colRes(0), acolRes(0) { } 
+
+  // Set info on initiator or remnant parton.
+  void iPos( int iPosIn) {iPosRes = iPosIn;} 
+  void id( int idIn) {idRes = idIn;} 
+  void x( double xIn) {xRes = xIn;} 
+  void update( int iPosIn, int idIn, double xIn) {iPosRes = iPosIn;
+    idRes = idIn; xRes = xIn;} 
+  void companion( int companionIn) {companionRes = companionIn;} 
+  void xqCompanion( double xqCompIn) {xqCompRes = xqCompIn;} 
+  void p(Vec4 pIn) {pRes = pIn;}
+  void px(double pxIn) {pRes.px(pxIn);}
+  void py(double pyIn) {pRes.py(pyIn);}
+  void pz(double pzIn) {pRes.pz(pzIn);}
+  void e(double eIn) {pRes.e(eIn);}
+  void m(double mIn) {mRes = mIn;}
+  void col(int colIn) {colRes = colIn;}
+  void acol(int acolIn) {acolRes = acolIn;}
+  void cols(int colIn = 0,int acolIn = 0) 
+    {colRes = colIn; acolRes = acolIn;} 
+  void scalePT( double factorIn) {pRes.px(factorIn * pRes.px()); 
+    pRes.py(factorIn * pRes.py()); factorRes *= factorIn;}
+  void scaleX( double factorIn) {xRes *= factorIn;}
+
+  // Get info on initiator or remnant parton.
+  int    iPos()        const {return iPosRes;} 
+  int    id()          const {return idRes;} 
+  double x()           const {return xRes;} 
+  int    companion()   const {return companionRes;} 
+  bool   isValence()   const {return (companionRes == -3);}
+  bool   isUnmatched() const {return (companionRes == -2);}
+  bool   isCompanion() const {return (companionRes >= 0);}
+  bool   isFromBeam()  const {return (companionRes > -10);}
+  double xqCompanion() const {return xqCompRes;} 
+  Vec4   p()           const {return pRes;}
+  double px()          const {return pRes.px();}
+  double py()          const {return pRes.py();}
+  double pz()          const {return pRes.pz();}
+  double e()           const {return pRes.e();}
+  double m()           const {return mRes;}
+  double pT()          const {return pRes.pT();}
+  double mT2()         const {return (mRes >= 0.) 
+    ? mRes*mRes + pRes.pT2() : - mRes*mRes + pRes.pT2();}
+  double pPos()        const {return pRes.e() +  pRes.pz();}
+  double pNeg()        const {return pRes.e() -  pRes.pz();}
+  int    col()         const {return colRes;}
+  int    acol()        const {return acolRes;}
+  double pTfactor()    const {return factorRes;} 
+private:
+
+  // Properties of a resolved parton. 
+  int    iPosRes, idRes;
+  double xRes;
+  // Companion code and distribution value, if any.
+  int    companionRes; 
+  double xqCompRes;
+  // Four-momentum and mass; for remnant kinematics construction.
+  Vec4   pRes;
+  double mRes, factorRes;
+  // Colour codes.
+  int   colRes, acolRes;
+
+};
+
+//==========================================================================
+
+// This class holds info on a beam particle in the evolution of 
+// initial-state radiation and multiple interactions.
+
+class BeamParticle {
+
+public:
+
+  // Constructor.
+  BeamParticle() : nInit(0) {Q2ValFracSav = -1.;}  
+
+  // Initialize data on a beam particle and save pointers.
+  void init( int idIn, double pzIn, double eIn, double mIn, 
+    Info* infoPtrIn, Settings& settings, ParticleData* particleDataPtrIn, 
+    Rndm* rndmPtrIn, PDF* pdfInPtr, PDF* pdfHardInPtr, bool isUnresolvedIn, 
+    StringFlav* flavSelPtrIn);
+
+  // For mesons like pi0 valence content varies from event to event.
+  void newValenceContent();
+
+  // Set new pZ and E, but keep the rest the same.
+  void newPzE( double pzIn, double eIn) {pBeam = Vec4( 0., 0., pzIn, eIn);}
+
+  // Member functions for output.
+  int id() const {return idBeam;}
+  Vec4 p() const {return pBeam;}
+  double px() const {return pBeam.px();}
+  double py() const {return pBeam.py();}
+  double pz() const {return pBeam.pz();}
+  double e() const {return pBeam.e();}
+  double m() const {return mBeam;}
+  bool isLepton() const {return isLeptonBeam;}
+  bool isUnresolved() const {return isUnresolvedBeam;}
+  // As hadrons here we only count those we know how to handle remnants for.
+  bool isHadron() const {return isHadronBeam;}
+  bool isMeson() const {return isMesonBeam;}
+  bool isBaryon() const {return isBaryonBeam;}
+
+  // Maximum x remaining after previous MI and ISR, plus safety margin.
+  double xMax(int iSkip = -1);
+
+  // Special hard-process parton distributions (can agree with standard ones).
+  double xfHard(int idIn, double x, double Q2) 
+    {return pdfHardBeamPtr->xf(idIn, x, Q2);}
+   
+  // Standard parton distributions.
+  double xf(int idIn, double x, double Q2) 
+    {return pdfBeamPtr->xf(idIn, x, Q2);}
+
+  // Ditto, split into valence and sea parts (where gluon counts as sea).
+  double xfVal(int idIn, double x, double Q2) 
+    {return pdfBeamPtr->xfVal(idIn, x, Q2);}
+  double xfSea(int idIn, double x, double Q2) 
+    {return pdfBeamPtr->xfSea(idIn, x, Q2);}
+
+  // Rescaled parton distributions, as needed for MI and ISR.
+  // For ISR also allow split valence/sea, and only return relevant part.
+  double xfMI(int idIn, double x, double Q2) 
+    {return xfModified(-1, idIn, x, Q2);}
+  double xfISR(int indexMI, int idIn, double x, double Q2) 
+    {return xfModified( indexMI, idIn, x, Q2);}
+
+  // Decide whether chosen quark is valence, sea or companion.
+  int pickValSeaComp();
+
+  // Initialize kind of incoming beam particle.
+  void initBeamKind();
+
+  // Overload index operator to access a resolved parton from the list.
+  ResolvedParton& operator[](int i) {return resolved[i];}
+
+  // Total number of partons extracted from beam, and initiators only.
+  int size() const {return resolved.size();}
+  int sizeInit() const {return nInit;}
+
+  // Clear list of resolved partons. 
+  void clear() {resolved.resize(0); nInit = 0;}
+
+  // Add a resolved parton to list. 
+  int append( int iPos, int idIn, double x, int companion = -1)
+    {resolved.push_back( ResolvedParton( iPos, idIn, x, companion) );
+    return resolved.size() - 1;}
+
+  // Print extracted parton list; for debug mainly.
+  void list(ostream& os = cout) const; 
+
+  // How many different flavours, and how many quarks of given flavour.
+  int nValenceKinds() const {return nValKinds;}
+  int nValence(int idIn) const {for (int i = 0; i < nValKinds; ++i) 
+    if (idIn == idVal[i]) return nVal[i]; return 0;}
+
+  // Test whether a lepton is to be considered as unresolved.
+  bool isUnresolvedLepton();
+
+  // Add extra remnant flavours to make valence and sea come out right. 
+  bool remnantFlavours(Event& event); 
+
+  // Correlate all initiators and remnants to make a colour singlet. 
+  bool remnantColours(Event& event, vector<int>& colFrom,
+    vector<int>& colTo); 
+
+  // Pick unrescaled x of remnant parton (valence or sea).
+  double xRemnant(int i);
+
+  // Tell whether a junction has been resolved, and its junction colours.
+  bool hasJunction() const {return hasJunctionBeam;}  
+  int junctionCol(int i) const {return junCol[i];}
+  void junctionCol(int i, int col) {junCol[i] = col;}
+
+  // For a diffractive system, decide whether to kick out gluon or quark.
+  bool pickGluon(double mDiff);
+
+  // Pick a valence quark at random, and provide the remaining flavour.
+  int pickValence();
+  int pickRemnant() const {return idVal2;}
+
+  // Share lightcone momentum between two remnants in a diffractive system.
+  // At the same time generate a relative pT for the two.
+  double zShare( double mDiff, double m1, double m2);
+  double pxShare() const {return pxRel;}
+  double pyShare() const {return pyRel;}
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const double XMINUNRESOLVED;
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*         rndmPtr;
+  // Pointers to PDF sets.
+  PDF*          pdfBeamPtr;
+  PDF*          pdfHardBeamPtr;
+
+  // Pointer to class for flavour generation.
+  StringFlav*   flavSelPtr;
+
+  // Initialization data, normally only set once.
+  bool   allowJunction;
+  int    maxValQuark, companionPower;
+  double valencePowerMeson, valencePowerUinP, valencePowerDinP, 
+         valenceDiqEnhance, pickQuarkNorm, pickQuarkPower, 
+         diffPrimKTwidth, diffLargeMassSuppress;
+
+  // Basic properties of a beam particle.
+  int    idBeam, idBeamAbs;  
+  Vec4   pBeam;
+  double mBeam;
+  // Beam kind. Valence flavour content for hadrons.
+  bool   isLeptonBeam, isUnresolvedBeam, isHadronBeam, isMesonBeam, 
+         isBaryonBeam;
+  int    nValKinds, idVal[3], nVal[3];
+
+  // Current parton density, by valence, sea and companion.
+  int    idSave, iSkipSave, nValLeft[3]; 
+  double xqgTot, xqVal, xqgSea, xqCompSum;
+
+  // The list of resolved partons.
+  vector<ResolvedParton> resolved; 
+
+  // Status after all initiators have been accounted for. Junction content.
+  int    nInit;
+  bool   hasJunctionBeam;
+  int    junCol[3];
+
+  // Routine to calculate pdf's given previous interactions.
+  double xfModified( int iSkip, int idIn, double x, double Q2); 
+
+  // Fraction of hadron momentum sitting in a valence quark distribution.
+  double xValFrac(int j, double Q2);
+  double Q2ValFracSav, uValInt, dValInt;
+
+  // Fraction of hadron momentum sitting in a companion quark distribution.
+  double xCompFrac(double xs);
+
+  // Value of companion quark PDF, also given the sea quark x.
+  double xCompDist(double xc, double xs);
+
+  // Valence quark subdivision for diffractive systems.
+  int    idVal1, idVal2, idVal3;
+  double zRel, pxRel, pyRel;
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_BeamParticle_H
diff --git a/PYTHIA8/pythia8140/include/BeamRemnants.h b/PYTHIA8/pythia8140/include/BeamRemnants.h
new file mode 100644 (file)
index 0000000..af7be2f
--- /dev/null
@@ -0,0 +1,96 @@
+// BeamRemnants.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for beam-remnants handling.
+// BeamRemnants: matches the remnants between the two beams.
+
+#ifndef Pythia8_BeamRemnants_H
+#define Pythia8_BeamRemnants_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PartonSystems.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// This class matches the kinematics of the hard-scattering subsystems
+// (with primordial kT added) to that of the two beam remnants.  
+
+class BeamRemnants {
+
+public:
+
+  // Constructor.
+  BeamRemnants() { }  
+
+  // Initialization.
+  bool init( Info* infoPtrIn, Settings& settings, Rndm* rndmPtrIn, 
+    BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, 
+    PartonSystems* partonSystemsPtrIn);
+
+  // New beams possible for handling of hard diffraction.
+  void reassignBeamPtrs( BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn) 
+    {beamAPtr = beamAPtrIn; beamBPtr = beamBPtrIn;}
+
+  // Select the flavours/kinematics/colours of the two beam remnants. 
+  bool add( Event& event);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const bool   ALLOWCOLOURTWICE, CORRECTMISMATCH;
+  static const int    NTRYCOLMATCH, NTRYKINMATCH;
+
+  // Initialization data, read from Settings.
+  bool   doPrimordialKT, allowRescatter, doRescatterRestoreY, doReconnect;
+  double primordialKTsoft, primordialKThard, primordialKTremnant,
+         halfScaleForKT, halfMassForKT, reconnectRange, 
+         pT0Ref, ecmRef, ecmPow;
+
+  // Information set for events.
+  int    nSys, oldSize;
+  double eCM, sCM, pT0, pT20Rec;
+
+  // Colour collapses (when one colour is mapped onto another).
+  vector<int> colFrom, colTo;
+
+  // Pointer to various information on the generation.
+  Info*          infoPtr;
+
+  // Pointer to the random number generator.
+  Rndm*          rndmPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle*  beamAPtr;
+  BeamParticle*  beamBPtr;
+
+  // Pointer to information on subcollision parton locations.
+  PartonSystems* partonSystemsPtr;
+
+  // Do the kinematics of the collision subsystems and two beam remnants. 
+  bool setKinematics( Event& event);
+
+  // Allow colour reconnections.
+  bool reconnectColours( Event&  event);
+
+  // Check that colours are consistent.
+  bool checkColours( Event& event);
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_BeamRemnants_H
diff --git a/PYTHIA8/pythia8140/include/BeamShape.h b/PYTHIA8/pythia8140/include/BeamShape.h
new file mode 100644 (file)
index 0000000..d89e861
--- /dev/null
@@ -0,0 +1,64 @@
+// BeamShape.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header for classes to set beam momentum and interaction vertex spread.
+
+#ifndef Pythia8_BeamShape_H
+#define Pythia8_BeamShape_H
+
+#include "Basics.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// Base class to set beam momentum and interaction spot spread.
+
+class BeamShape {
+
+public:
+
+  // Constructor.
+  BeamShape() {}
+
+  // Destructor.
+  virtual ~BeamShape() {}
+
+  // Initialize beam parameters.
+  virtual void init( Settings& settings, Rndm* rndmPtrIn);
+
+  // Set the two beam momentum deviations and the beam vertex.
+  virtual void pick();
+
+  // Methods to read out the choice made with the above method.
+  Vec4 deltaPA() const {return Vec4( deltaPxA, deltaPyA, deltaPzA, 0);}
+  Vec4 deltaPB() const {return Vec4( deltaPxB, deltaPyB, deltaPzB, 0);}
+  Vec4 vertex()  const {return Vec4( vertexX, vertexY, vertexZ, vertexT);}
+
+protected:
+
+  // Values to be set.
+  double deltaPxA, deltaPyA, deltaPzA, deltaPxB, deltaPyB, deltaPzB,
+         vertexX, vertexY, vertexZ, vertexT;
+  
+  // Parameters of Gaussian parametrizations.
+  bool   allowMomentumSpread, allowVertexSpread;
+  double sigmaPxA, sigmaPyA, sigmaPzA, maxDevA, sigmaPxB, sigmaPyB, 
+         sigmaPzB, maxDevB, sigmaVertexX, sigmaVertexY, sigmaVertexZ, 
+         maxDevVertex, sigmaTime, maxDevTime, offsetX, offsetY, 
+         offsetZ, offsetT;
+
+  // Pointer to the random number generator.
+  Rndm*  rndmPtr;
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_BeamShape_H
diff --git a/PYTHIA8/pythia8140/include/BoseEinstein.h b/PYTHIA8/pythia8140/include/BoseEinstein.h
new file mode 100644 (file)
index 0000000..48f0f43
--- /dev/null
@@ -0,0 +1,92 @@
+// Bose-Einstein.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the classes to handle Bose-Einstein effects.
+// BoseEinsteinHadron: simple working container for particle momenta.
+// BoseEinstein: main class to perform the task.
+
+#ifndef Pythia8_BoseEinstein_H
+#define Pythia8_BoseEinstein_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+//==========================================================================
+// The BoseEinsteinHadron class is a simple container for studied hadrons.
+
+class BoseEinsteinHadron {
+
+public:
+
+  // Constructors. 
+  BoseEinsteinHadron() : id(0), iPos(0), p(0.), pShift(0.), pComp(0.), 
+    m2(0.) {}
+  BoseEinsteinHadron(int idIn,  int iPosIn, Vec4 pIn, double mIn) : 
+    id(idIn), iPos(iPosIn), p(pIn), pShift(0.), pComp(0.) {m2 = mIn*mIn;}
+
+  // Information on hadron - all public.
+  int    id, iPos;
+  Vec4   p, pShift, pComp;
+  double m2;
+
+};
+
+//==========================================================================
+
+// The BoseEinstein class shifts the momenta of identical particles relative 
+// to each other, to simulate Bose-Einstein effects to some approximation.
+
+class BoseEinstein {
+
+public:
+
+  // Constructor. 
+  BoseEinstein() {}
+
+  // Find settings. Precalculate table used to find momentum shifts.
+  bool init(Info* infoPtrIn, Settings& settings, ParticleData& particleData);
+
+  // Perform Bose-Einstein corrections on an event.
+  bool shiftEvent( Event& event); 
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    IDHADRON[9], ITABLE[9], NCOMPSTEP;
+  static const double STEPSIZE, Q2MIN, COMPRELERR, COMPFACMAX;
+
+  // Initialization data, read from Settings.
+  bool   doPion, doKaon, doEta;
+  double lambda, QRef;
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // Table of momentum shifts for different hadron species.
+  int    nStep[4], nStep3[4], nStored[10];
+  double QRef2, QRef3, R2Ref, R2Ref2, R2Ref3, mHadron[9],
+         mPair[4], m2Pair[4], deltaQ[4], deltaQ3[4], maxQ[4], maxQ3[4];
+  double shift[4][200], shift3[4][200]; 
+
+  // Vector of hadrons to study.
+  vector<BoseEinsteinHadron> hadronBE;
+
+  // Calculate shift and (unnormalized) compensation for pair.
+  void shiftPair(int i1, int i2, int iHad);
+  
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_BoseEinstein_H
+
diff --git a/PYTHIA8/pythia8140/include/Event.h b/PYTHIA8/pythia8140/include/Event.h
new file mode 100644 (file)
index 0000000..697917b
--- /dev/null
@@ -0,0 +1,566 @@
+// Event.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for the Particle and Event classes.
+// Particle: information on an instance of a particle.
+// Junction: information on a junction between three colours.
+// Event: list of particles in the current event.
+
+#ifndef Pythia8_Event_H
+#define Pythia8_Event_H
+
+#include "Basics.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Forward references to ParticleDataEntry and ResonanceWidths classes.
+class ParticleDataEntry;
+class ResonanceWidths;
+
+//==========================================================================
+
+// Particle class.
+// This class holds info on a particle in general.
+
+class Particle {
+
+public:
+
+  // Constructors.
+  Particle() : idSave(0), statusSave(0), mother1Save(0), mother2Save(0), 
+    daughter1Save(0), daughter2Save(0), colSave(0), acolSave(0), 
+    pSave(Vec4(0.,0.,0.,0.)), mSave(0.), scaleSave(0.), 
+    hasVertexSave(false), vProdSave(Vec4(0.,0.,0.,0.)), tauSave(0.), 
+    pdePtr(0), pdtPtr(0) { }  
+  Particle(int idIn, int statusIn = 0, int mother1In = 0, 
+    int mother2In = 0, int daughter1In = 0, int daughter2In = 0,
+    int colIn = 0, int acolIn = 0, double pxIn = 0., double pyIn = 0., 
+    double pzIn = 0., double eIn = 0., double mIn = 0., double scaleIn = 0.) 
+    : idSave(idIn), statusSave(statusIn), mother1Save(mother1In), 
+    mother2Save(mother2In), daughter1Save(daughter1In), 
+    daughter2Save(daughter2In), colSave(colIn), acolSave(acolIn), 
+    pSave(Vec4(pxIn, pyIn, pzIn, eIn)), mSave(mIn), scaleSave(scaleIn), 
+    hasVertexSave(false), vProdSave(Vec4(0.,0.,0.,0.)), tauSave(0.), 
+    pdePtr(0), pdtPtr(0) { }  
+  Particle(int idIn, int statusIn, int mother1In, int mother2In, 
+    int daughter1In, int daughter2In, int colIn, int acolIn, 
+    Vec4 pIn, double mIn = 0., double scaleIn = 0.) 
+    : idSave(idIn), statusSave(statusIn), mother1Save(mother1In), 
+    mother2Save(mother2In), daughter1Save(daughter1In), 
+    daughter2Save(daughter2In), colSave(colIn), acolSave(acolIn), 
+    pSave(pIn), mSave(mIn), scaleSave(scaleIn), hasVertexSave(false), 
+    vProdSave(Vec4(0.,0.,0.,0.)), tauSave(0.), pdePtr(0), pdtPtr(0) { }  
+  Particle(const Particle& pt) : idSave(pt.idSave), 
+    statusSave(pt.statusSave), mother1Save(pt.mother1Save), 
+    mother2Save(pt.mother2Save), daughter1Save(pt.daughter1Save), 
+    daughter2Save(pt.daughter2Save), colSave(pt.colSave), 
+    acolSave(pt.acolSave), pSave(pt.pSave), mSave(pt.mSave), 
+    scaleSave(pt.scaleSave), hasVertexSave(pt.hasVertexSave), 
+    vProdSave(pt.vProdSave), tauSave(pt.tauSave), 
+    pdePtr(pt.pdePtr), pdtPtr(pt.pdtPtr) { } 
+  Particle& operator=(const Particle& pt) {if (this != &pt) {
+    idSave = pt.idSave; statusSave = pt.statusSave; 
+    mother1Save = pt.mother1Save; mother2Save = pt.mother2Save; 
+    daughter1Save = pt.daughter1Save; daughter2Save = pt.daughter2Save; 
+    colSave = pt.colSave; acolSave = pt.acolSave; pSave = pt.pSave; 
+    mSave = pt.mSave; scaleSave = pt.scaleSave; 
+    hasVertexSave = pt.hasVertexSave; vProdSave = pt.vProdSave; 
+    tauSave = pt.tauSave; pdePtr = pt.pdePtr; pdtPtr = pt.pdtPtr; } 
+    return *this; } 
+
+  // Member functions to set the ParticleData and ParticleDataEntry pointers.
+  void setPDTPtr(ParticleData* pdtPtrIn) { pdtPtr = pdtPtrIn; setPDEPtr();}
+  void setPDEPtr() {pdePtr = (pdtPtr > 0) 
+    ? pdtPtr->particleDataEntryPtr( idSave) : 0;}
+      
+  // Member functions for input.
+  void id(int idIn) {idSave = idIn; setPDEPtr();}
+  void status(int statusIn) {statusSave = statusIn;}
+  void statusPos() {statusSave = abs(statusSave);}
+  void statusNeg() {statusSave = -abs(statusSave);}
+  void statusCode(int statusIn) {statusSave = 
+    (statusSave > 0) ? abs(statusIn) : -abs(statusIn);}
+  void mother1(int mother1In) {mother1Save = mother1In;}
+  void mother2(int mother2In) {mother2Save = mother2In;}
+  void mothers(int mother1In = 0, int mother2In = 0) 
+    {mother1Save = mother1In; mother2Save = mother2In;}
+  void daughter1(int daughter1In) {daughter1Save = daughter1In;}
+  void daughter2(int daughter2In) {daughter2Save = daughter2In;}
+  void daughters(int daughter1In = 0, int daughter2In = 0) 
+    {daughter1Save = daughter1In; daughter2Save = daughter2In;}  
+  void col(int colIn) {colSave = colIn;}
+  void acol(int acolIn) {acolSave = acolIn;}
+  void cols(int colIn = 0,int acolIn = 0) {colSave = colIn; 
+    acolSave = acolIn;}  
+  void p(Vec4 pIn) {pSave = pIn;}
+  void p(double pxIn, double pyIn, double pzIn, double eIn) 
+    {pSave.p(pxIn, pyIn, pzIn, eIn);}
+  void px(double pxIn) {pSave.px(pxIn);}
+  void py(double pyIn) {pSave.py(pyIn);}
+  void pz(double pzIn) {pSave.pz(pzIn);}
+  void e(double eIn) {pSave.e(eIn);}
+  void m(double mIn) {mSave = mIn;}
+  void scale(double scaleIn) {scaleSave = scaleIn;}
+  void vProd(Vec4 vProdIn) {vProdSave = vProdIn; hasVertexSave = true;}
+  void vProd(double xProdIn, double yProdIn, double zProdIn, double tProdIn)
+    {vProdSave.p(xProdIn, yProdIn, zProdIn, tProdIn); hasVertexSave = true;}
+  void xProd(double xProdIn) {vProdSave.px(xProdIn); hasVertexSave = true;} 
+  void yProd(double yProdIn) {vProdSave.py(yProdIn); hasVertexSave = true;} 
+  void zProd(double zProdIn) {vProdSave.pz(zProdIn); hasVertexSave = true;} 
+  void tProd(double tProdIn) {vProdSave.e(tProdIn); hasVertexSave = true;} 
+  void tau(double tauIn) {tauSave = tauIn;} 
+
+  // Member functions for output.
+  int    id()        const {return idSave;}
+  int    status()    const {return statusSave;}
+  int    mother1()   const {return mother1Save;}
+  int    mother2()   const {return mother2Save;}
+  int    daughter1() const {return daughter1Save;}
+  int    daughter2() const {return daughter2Save;}
+  int    col()       const {return colSave;}
+  int    acol()      const {return acolSave;}
+  Vec4   p()         const {return pSave;}
+  double px()        const {return pSave.px();}
+  double py()        const {return pSave.py();}
+  double pz()        const {return pSave.pz();}
+  double e()         const {return pSave.e();}
+  double m()         const {return mSave;}
+  double scale()     const {return scaleSave;}
+  bool   hasVertex() const {return hasVertexSave;}
+  Vec4   vProd()     const {return vProdSave;}
+  double xProd()     const {return vProdSave.px();}
+  double yProd()     const {return vProdSave.py();}
+  double zProd()     const {return vProdSave.pz();}
+  double tProd()     const {return vProdSave.e();}
+  double tau()       const {return tauSave;}
+
+  // Member functions for output; derived int and bool quantities.
+  int    idAbs()     const {return abs(idSave);}
+  int    statusAbs() const {return abs(statusSave);}
+  bool   isFinal()   const {return (statusSave > 0);}
+  bool   isRescatteredIncoming() const {return 
+    (statusSave == -34 || statusSave == -45 ||
+     statusSave == -46 || statusSave == -54);}
+
+  // Member functions for output; derived double quantities.
+  double m2()        const {return (mSave >= 0.) ?  mSave*mSave 
+                                                 : -mSave*mSave;}
+  double mCalc()     const {return pSave.mCalc();}
+  double m2Calc()    const {return pSave.m2Calc();}
+  double eCalc()     const {return sqrt(abs(m2() + pSave.pAbs2()));}
+  double pT()        const {return pSave.pT();}
+  double pT2()       const {return pSave.pT2();}
+  double mT()        const {double temp = m2() + pSave.pT2(); 
+    return (temp >= 0.) ? sqrt(temp) : -sqrt(-temp);}
+  double mT2()       const {return m2() + pSave.pT2();}
+  double pAbs()      const {return pSave.pAbs();}
+  double pAbs2()     const {return pSave.pAbs2();}
+  double eT()        const {return pSave.eT();}
+  double eT2()       const {return pSave.eT2();}
+  double theta()     const {return pSave.theta();}
+  double phi()       const {return pSave.phi();}
+  double thetaXZ()   const {return pSave.thetaXZ();}
+  double pPos()      const {return pSave.pPos();}
+  double pNeg()      const {return pSave.pNeg();}
+  double y()         const;
+  double eta()       const; 
+  Vec4   vDec()      const {return (tauSave > 0. && mSave > 0.) 
+    ? vProdSave + tauSave * pSave / mSave : vProdSave;}
+  double xDec()      const {return (tauSave > 0. && mSave > 0.) 
+    ? vProdSave.px() + tauSave * pSave.px() / mSave : vProdSave.px();}
+  double yDec()      const {return (tauSave > 0. && mSave > 0.)  
+    ? vProdSave.py() + tauSave * pSave.py() / mSave : vProdSave.py();}
+  double zDec()      const {return (tauSave > 0. && mSave > 0.)  
+    ? vProdSave.pz() + tauSave * pSave.pz() / mSave : vProdSave.pz();}
+  double tDec()      const {return (tauSave > 0. && mSave > 0.)  
+    ? vProdSave.e()  + tauSave * pSave.e()  / mSave : vProdSave.e();}
+
+  // Further output, based on a pointer to a ParticleDataEntry object.
+  string name()      const {
+    return (pdePtr > 0) ? pdePtr->name(idSave) : " ";}
+  string nameWithStatus(int maxLen = 20) const;
+  int    spinType()  const {
+    return (pdePtr > 0) ? pdePtr->spinType() : 0;}
+  int    chargeType() const {
+    return (pdePtr > 0) ? pdePtr->chargeType(idSave) : 0;}
+  double charge()    const {
+    return (pdePtr > 0) ?  pdePtr->charge(idSave) : 0;}
+  bool   isCharged() const {
+    return (pdePtr > 0) ? (pdePtr->chargeType(idSave) != 0) : false;}
+  bool   isNeutral() const {
+    return (pdePtr > 0) ? (pdePtr->chargeType(idSave) == 0) : false;}
+  int    colType()   const {
+    return (pdePtr > 0) ? pdePtr->colType(idSave) : 0;}
+  double m0()        const {
+    return (pdePtr > 0) ? pdePtr->m0() : 0.;}
+  double mWidth()    const {
+    return (pdePtr > 0) ? pdePtr->mWidth() : 0.;}
+  double mMin()      const {
+    return (pdePtr > 0) ? pdePtr->mMin() : 0.;}
+  double mMax()      const {
+    return (pdePtr > 0) ? pdePtr->mMax() : 0.;}
+  double mass()      const {
+    return (pdePtr > 0) ? pdePtr->mass() : 0.;}
+  double constituentMass() const {
+    return (pdePtr > 0) ? pdePtr->constituentMass() : 0.;}
+  double tau0()      const {
+    return (pdePtr > 0) ? pdePtr->tau0() : 0.;}
+  bool   mayDecay()  const {
+    return (pdePtr > 0) ? pdePtr->mayDecay() : false;}
+  bool   canDecay()  const {
+    return (pdePtr > 0) ? pdePtr->canDecay() : false;}
+  bool   doExternalDecay() const {
+    return (pdePtr > 0) ? pdePtr->doExternalDecay() : false;}
+  bool   isResonance() const {
+    return (pdePtr > 0) ? pdePtr->isResonance() : false;}
+  bool   isVisible() const {
+    return (pdePtr > 0) ? pdePtr->isVisible() : false;}
+  bool   isLepton()  const {
+    return  (pdePtr > 0) ? pdePtr->isLepton() : false;}
+  bool   isQuark()   const {
+    return  (pdePtr > 0) ? pdePtr->isQuark() : false;}
+  bool   isGluon()   const {
+    return (pdePtr > 0) ? pdePtr->isGluon() : false;}
+  bool   isHadron()  const {
+    return (pdePtr > 0) ? pdePtr->isHadron() : false;}
+  ParticleDataEntry& particleDataEntry() const {return *pdePtr;}
+
+  // Member functions that perform operations.
+  void rescale3(double fac) {pSave.rescale3(fac);}
+  void rescale4(double fac) {pSave.rescale4(fac);}
+  void rescale5(double fac) {pSave.rescale4(fac); mSave *= fac;}
+  void rot(double thetaIn, double phiIn) {pSave.rot(thetaIn, phiIn);
+    if (hasVertexSave) vProdSave.rot(thetaIn, phiIn);} 
+  void bst(double betaX, double betaY, double betaZ) {
+    pSave.bst(betaX, betaY, betaZ);
+    if (hasVertexSave) vProdSave.bst(betaX, betaY, betaZ);}
+  void bst(double betaX, double betaY, double betaZ, double gamma) {
+    pSave.bst(betaX, betaY, betaZ, gamma);
+    if (hasVertexSave) vProdSave.bst(betaX, betaY, betaZ, gamma);}
+  void bst(const Vec4& pBst) {pSave.bst(pBst);
+    if (hasVertexSave) vProdSave.bst(pBst);}
+  void bst(const Vec4& pBst, double mBst) {pSave.bst(pBst, mBst);
+    if (hasVertexSave) vProdSave.bst(pBst, mBst);}
+  void bstback(const Vec4& pBst) {pSave.bstback(pBst);
+    if (hasVertexSave) vProdSave.bstback(pBst);}
+  void bstback(const Vec4& pBst, double mBst) {pSave.bstback(pBst, mBst);
+    if (hasVertexSave) vProdSave.bstback(pBst, mBst);}
+  void rotbst(const RotBstMatrix& M) {pSave.rotbst(M);
+    if (hasVertexSave) vProdSave.rotbst(M);} 
+  void offsetHistory( int minMother, int addMother, int minDaughter, 
+    int addDaughter);
+  void offsetCol( int addCol); 
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double TINY;
+
+  // Properties of the current particle.
+  int    idSave, statusSave, mother1Save, mother2Save, daughter1Save, 
+         daughter2Save, colSave, acolSave;
+  Vec4   pSave;
+  double mSave, scaleSave;
+  bool   hasVertexSave;
+  Vec4   vProdSave;
+  double tauSave;
+
+  // Pointer to properties of the particle species.
+  // Should no be saved in a persistent copy of the event record.
+  // The //! below is ROOT notation that this member should not be saved.
+  // Event::restorePtrs() can be called to restore the missing information. 
+  ParticleDataEntry* pdePtr;  //!
+
+  // Pointer to the whole particle data table. Used to update the above pointer 
+  // when id(...) changes identity. As above it should not be saved.
+  ParticleData*      pdtPtr;  //!  
+
+};
+
+// Invariant mass of a pair and its square.
+// (Not part of class proper, but tightly linked.)
+double m(const Particle&, const Particle&); 
+double m2(const Particle&, const Particle&); 
+
+//==========================================================================
+
+// The junction class stores what kind of junction it is, the colour indices 
+// of the legs at the junction and as far out as legs have been traced,
+// and the status codes assigned for fragmentation of each leg.
+
+class Junction {
+
+public:
+
+  // Constructors.
+  Junction() : remainsSave(true), kindSave(0) { 
+    for (int j = 0; j < 3; ++j) {
+    colSave[j] = 0; endColSave[j] = 0; statusSave[j] = 0; } }
+  Junction( int kindIn, int col0In, int col1In, int col2In) 
+    : remainsSave(true), kindSave(kindIn) {colSave[0] = col0In; 
+    colSave[1] = col1In; colSave[2] = col2In; 
+    for (int j = 0; j < 3; ++j) {
+    endColSave[j] = colSave[j]; statusSave[j] = 0; } }
+  Junction(const Junction& ju) : remainsSave(ju.remainsSave), 
+    kindSave(ju.kindSave) { for (int j = 0; j < 3; ++j) {
+    colSave[j] = ju.colSave[j]; endColSave[j] = ju.endColSave[j]; 
+    statusSave[j] = ju.statusSave[j]; } }
+  Junction& operator=(const Junction& ju) {if (this != &ju) { 
+    remainsSave = ju.remainsSave; kindSave =  ju.kindSave; 
+    for (int j = 0; j < 3; ++j) { colSave[j] = ju.colSave[j]; 
+    endColSave[j] = ju.endColSave[j]; statusSave[j] = ju.statusSave[j]; } } 
+    return *this; }  
+
+  // Set values.
+  void remains(bool remainsIn) {remainsSave = remainsIn;}
+  void col(int j, int colIn) {colSave[j] = colIn; endColSave[j] = colIn;}
+  void cols(int j, int colIn, int endColIn) {colSave[j] = colIn; 
+    endColSave[j] = endColIn;}
+  void endCol(int j, int endColIn) {endColSave[j] = endColIn;}
+  void status(int j, int statusIn) {statusSave[j] = statusIn;}
+
+  // Read out value.
+  bool   remains()     const {return remainsSave;}
+  int    kind()        const {return kindSave;}
+  int    col(int j)    const {return colSave[j];}
+  int    endCol(int j) const {return endColSave[j];}
+  int    status(int j) const {return statusSave[j];}
+private:
+
+  // Kind, positions of the three ends and their status codes.
+  bool remainsSave;
+  int kindSave, colSave[3], endColSave[3], statusSave[3];
+
+};
+
+//==========================================================================
+
+// The Event class holds all info on the generated event.
+
+class Event {
+    
+public:
+
+  // Constructors.
+  Event(int capacity = 100) {entry.reserve(capacity); startColTag = 100; 
+    headerList = "----------------------------------------"; 
+    particleDataPtr = 0;}
+  Event& operator=(const Event& oldEvent);
+
+  // Initialize header for event listing, particle data table, and colour.
+  void init( string headerIn = "", ParticleData* particleDataPtrIn = 0, 
+    int startColTagIn = 100) {
+    headerList.replace(0, headerIn.length() + 2, headerIn + "  ");
+     particleDataPtr = particleDataPtrIn; startColTag = startColTagIn;}
+
+  // Clear event record.
+  void clear() {entry.resize(0); maxColTag = startColTag; scaleSave = 0.;
+    scaleSecondSave = 0.; clearJunctions();}
+
+  // Clear event record, and set first particle empty.
+  void reset() {clear(); append(90, -11, 0, 0, 0., 0., 0., 0., 0.);}
+
+  // Overload index operator to access element of event record.
+  Particle& operator[](int i) {return entry[i];}
+  const Particle& operator[](int i) const {return entry[i];}
+
+  // Event record size.
+  int size() const {return entry.size();}
+
+  // Put a new particle at the end of the event record; return index.
+  int append(Particle entryIn) {    
+    entry.push_back(entryIn); setPDTPtr();
+    if (entryIn.col() > maxColTag) maxColTag = entryIn.col();   
+    if (entryIn.acol() > maxColTag) maxColTag = entryIn.acol();
+    return entry.size() - 1;
+  }
+  int append(int id, int status, int mother1, int mother2, int daughter1, 
+    int daughter2, int col, int acol, double px, double py, double pz, 
+    double e, double m = 0., double scaleIn = 0.) {entry.push_back( 
+    Particle(id, status, mother1, mother2, daughter1, daughter2, col, acol, 
+    px, py, pz, e, m, scaleIn) ); setPDTPtr();
+    if (col > maxColTag) maxColTag = col;   
+    if (acol > maxColTag) maxColTag = acol;
+    return entry.size() - 1;
+  }
+  int append(int id, int status, int mother1, int mother2, int daughter1, 
+    int daughter2, int col, int acol, Vec4 p, double m = 0., 
+    double scaleIn = 0.) {entry.push_back( Particle(id, status, mother1, 
+    mother2, daughter1, daughter2, col, acol, p, m, scaleIn) ); setPDTPtr();
+    if (col > maxColTag) maxColTag = col;   
+    if (acol > maxColTag) maxColTag = acol;
+    return entry.size() - 1;
+  }
+
+  // Brief versions of append: no mothers and no daughters.
+  int append(int id, int status, int col, int acol, double px, double py, 
+    double pz, double e, double m = 0.) {entry.push_back( Particle(id, 
+    status, 0, 0, 0, 0, col, acol, px, py, pz, e, m, 0.) ); setPDTPtr();
+    if (col > maxColTag) maxColTag = col;   
+    if (acol > maxColTag) maxColTag = acol;
+    return entry.size() - 1;
+  }
+  int append(int id, int status, int col, int acol, Vec4 p, double m = 0.) 
+    {entry.push_back( Particle(id, status, 0, 0, 0, 0, col, acol, p, m, 0.) );
+    setPDTPtr(); 
+    if (col > maxColTag) maxColTag = col;   
+    if (acol > maxColTag) maxColTag = acol;
+    return entry.size() - 1;
+  }
+
+  // Set pointer to ParticleData for a particle, by default latest one.
+  void setPDTPtr(int iSet = -1) {if (iSet < 0) iSet = entry.size() - 1;
+    entry[iSet].setPDTPtr( particleDataPtr);}
+
+  // Add a copy of an existing particle at the end of the event record.
+  int copy(int iCopy, int newStatus = 0);
+
+  // Implement reference "back" to access last element.
+  Particle& back() {return entry.back();}
+
+  // List the particles in an event.
+  void list() const; 
+  void list(ostream& os) const; 
+  void list(bool showScaleAndVertex, bool showMothersAndDaughters = false)
+    const;
+  void list(bool showScaleAndVertex, bool showMothersAndDaughters,
+    ostream& os) const;
+
+  // Remove last n entries.
+  void popBack(int nRemove = 1) { if (nRemove ==1) entry.pop_back();
+    else {int newSize = max( 0, size() - nRemove); 
+    entry.resize(newSize);} } 
+
+  // Restore all ParticleDataEntry* pointers in the Particle vector.
+  // Useful when a persistent copy of the event record is read back in.
+  void restorePtrs() { for (int i = 0; i < size(); ++i) setPDTPtr(i); } 
+
+  // Save or restore the size of the event record (throwing at the end).
+  void saveSize() {savedSize = entry.size();}
+  void restoreSize() {entry.resize(savedSize);}   
+
+  // Initialize and access colour tag information.
+  void initColTag(int colTag = 0) {maxColTag = max( colTag,startColTag);}
+  int lastColTag() const {return maxColTag;}
+  int nextColTag() {return ++maxColTag;}
+
+  // Access scale for which event as a whole is defined.
+  void scale( double scaleIn) {scaleSave = scaleIn;}
+  double scale() const {return scaleSave;}
+
+  // Need a second scale if two hard interactions in event.
+  void scaleSecond( double scaleSecondIn) {scaleSecondSave = scaleSecondIn;}
+  double scaleSecond() const {return scaleSecondSave;}
+
+  // Find complete list of daughters and mothers.
+  vector<int> motherList(int i) const;
+  vector<int> daughterList(int i) const;
+
+  // Convert to HepMC status code conventions.
+  int statusHepMC(int i) const;
+
+  // Trace the first and last copy of one and the same particle.
+  int iTopCopy(int i) const;
+  int iBotCopy(int i) const;
+
+  // Trace the first and last copy of a particle, using flavour match.
+  int iTopCopyId(int i) const;
+  int iBotCopyId(int i) const;
+
+  // Find list of sisters, also tracking up and down identical copies.
+  vector<int> sisterList(int i) const;
+  vector<int> sisterListTopBot(int i, bool widenSearch = true) const;
+
+  // Check whether two particles have a direct mother-daughter relation.
+  bool isAncestor(int i, int iAncestor) const;
+
+  // Member functions for rotations and boosts of an event.
+  void rot(double theta, double phi) 
+    {for (int i = 0; i < size(); ++i) entry[i].rot(theta, phi);} 
+  void bst(double betaX, double betaY, double betaZ) 
+    {for (int i = 0; i < size(); ++i) entry[i].bst(betaX, betaY, betaZ);}
+  void bst(double betaX, double betaY, double betaZ, double gamma) 
+    {for (int i = 0; i < size(); ++i) entry[i].bst(betaX, betaY, betaZ, 
+    gamma);}
+  void bst(const Vec4& vec) 
+    {for (int i = 0; i < size(); ++i) entry[i].bst(vec);}
+  void rotbst(const RotBstMatrix& M) 
+    {for (int i = 0; i < size(); ++i) entry[i].rotbst(M);}
+
+  // Clear the list of junctions.
+  void clearJunctions() {junction.resize(0);}
+  // Add a junction to the list, study it or extra input.
+  void appendJunction( int kind, int col0, int col1, int col2)  
+    { junction.push_back( Junction( kind, col0, col1, col2) );} 
+  void appendJunction(Junction junctionIn) {junction.push_back(junctionIn);} 
+  int sizeJunction() const {return junction.size();}
+  bool remainsJunction(int i) const {return junction[i].remains();}
+  void remainsJunction(int i, bool remainsIn) {junction[i].remains(remainsIn);}
+  int kindJunction(int i) const {return junction[i].kind();}
+  int colJunction( int i, int j) const {return junction[i].col(j);}
+  void colJunction( int i, int j, int colIn) {junction[i].col(j, colIn);}
+  int endColJunction( int i, int j) const {return junction[i].endCol(j);}
+  void endColJunction( int i, int j, int endColIn) 
+    {junction[i].endCol(j, endColIn);}
+  int statusJunction( int i, int j) const {return junction[i].status(j);}
+  void statusJunction( int i, int j, int statusIn) 
+    {junction[i].status(j, statusIn);}
+  Junction& getJunction(int i) {return junction[i];}
+  const Junction& getJunction(int i) const {return junction[i];}
+  void eraseJunction(int i);
+
+  // Save or restore the size of the junction list (throwing at the end).
+  void saveJunctionSize() {savedJunctionSize = junction.size();}
+  void restoreJunctionSize() {junction.resize(savedJunctionSize);}   
+
+  // List any junctions in the event; for debug mainly.
+  void listJunctions(ostream& os = cout) const;
+
+  // Operator overloading allows to append one event to an existing one.
+  // Warning: particles should be OK, but some other information unreliable.
+  Event& operator+=(const Event& addEvent);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int IPERLINE;
+
+  // Initialization data, normally only set once.
+  int startColTag;
+
+  // The event: a vector containing all particles (entries).
+  vector<Particle> entry;
+
+  // The list of junctions.
+  vector<Junction> junction;
+
+  // The maximum colour tag of the event so far.
+  int maxColTag;
+
+  // Saved entry and junction list sizes, for simple restoration.
+  int savedSize, savedJunctionSize;
+
+  // The scale of the event; linear quantity in GeV.
+  double scaleSave, scaleSecondSave;
+
+  // Header specification in event listing (at most 40 characters wide).
+  string headerList;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+  
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // end Pythia8_Event_H
diff --git a/PYTHIA8/pythia8140/include/FragmentationFlavZpT.h b/PYTHIA8/pythia8140/include/FragmentationFlavZpT.h
new file mode 100644 (file)
index 0000000..4af59d9
--- /dev/null
@@ -0,0 +1,179 @@
+// FragmentationFlavZpT.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains helper classes for fragmentation.
+// StringFlav is used to select quark and hadron flavours.
+// StringPT is used to select transverse momenta.
+// StringZ is used to sample the fragmentation function f(z).
+
+#ifndef Pythia8_FragmentationFlavZpT_H
+#define Pythia8_FragmentationFlavZpT_H
+
+#include "Basics.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+
+//==========================================================================
+
+// The FlavContainer class is a simple container for flavour, 
+// including the extra properties needed for popcorn baryon handling.
+// id = current flavour. 
+// rank = current rank; 0 for endpoint flavour and then increase by 1.
+// nPop = number of popcorn mesons yet to be produced (1 or 0).
+// idPop = (absolute sign of) popcorn quark, shared between B and Bbar.
+// idVtx = (absolute sign of) vertex (= non-shared) quark in diquark.
+
+class FlavContainer {
+
+public:
+
+  // Constructor. 
+  FlavContainer(int idIn = 0, int rankIn = 0, int nPopIn = 0, 
+    int idPopIn = 0, int idVtxIn = 0) : id(idIn), rank(rankIn), 
+    nPop(nPopIn), idPop(idPopIn), idVtx(idVtxIn) {}
+
+  // Overloaded equal operator.
+  FlavContainer& operator=(const FlavContainer& flav) { if (this != &flav) { 
+    id = flav.id; rank = flav.rank; nPop = flav.nPop; idPop = flav.idPop;
+    idVtx = flav.idVtx; } return *this; }
+
+  // Invert flavour.
+  FlavContainer& anti() {id = -id; return *this;}
+
+  // Read in a container into another, without/with id sign flip.
+  FlavContainer& copy(const FlavContainer& flav) { if (this != &flav) { 
+    id = flav.id; rank = flav.rank; nPop = flav.nPop; idPop = flav.idPop;
+    idVtx = flav.idVtx; } return *this; }
+  FlavContainer& anti(const FlavContainer& flav) { if (this != &flav) { 
+    id = -flav.id; rank = flav.rank; nPop = flav.nPop; idPop = flav.idPop;
+    idVtx = flav.idVtx; } return *this; }
+
+  // Stored properties.
+  int id, rank, nPop, idPop, idVtx;
+  
+};
+
+//==========================================================================
+
+// The StringFlav class is used to select quark and hadron flavours.
+
+class StringFlav {
+
+public:
+
+  // Constructor. 
+  StringFlav() {}
+
+  // Initialize data members.
+  void init(Settings& settings, Rndm* rndmPtrIn);
+
+  // Pick a light d, u or s quark according to fixed ratios.
+  int pickLightQ() { double rndmFlav = probQandS * rndmPtr->flat();
+    if (rndmFlav < 1.) return 1; if (rndmFlav < 2.) return 2; return 3; }
+
+  // Pick a new flavour (including diquarks) given an incoming one.
+  FlavContainer pick(FlavContainer& flavOld);
+
+  // Combine two flavours (including diquarks) to produce a hadron.
+  int combine(FlavContainer& flav1, FlavContainer& flav2);
+
+  // Assign popcorn quark inside an original (= rank 0) diquark.
+  void assignPopQ(FlavContainer& flav);
+
+  // Combine two quarks to produce a diquark.
+  int makeDiquark(int id1, int id2, int idHad = 0);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    mesonMultipletCode[6];
+  static const double baryonCGOct[6], baryonCGDec[6]; 
+
+  // Initialization data, to be read from Settings.
+  bool   suppressLeadingB;
+  double probQQtoQ, probStoUD, probSQtoQQ, probQQ1toQQ0, probQandQQ, 
+         probQandS, probQandSinQQ, probQQ1corr, probQQ1corrInv, probQQ1norm, 
+         mesonRate[4][6], mesonRateSum[4], mesonMix1[2][6], mesonMix2[2][6], 
+         etaSup, etaPrimeSup, decupletSup, baryonCGSum[6], baryonCGMax[6], 
+         popcornRate, popcornSpair, popcornSmeson, scbBM[3], popFrac, 
+         popS[3], dWT[3][7], lightLeadingBSup, heavyLeadingBSup;
+
+  // Pointer to the random number generator.
+  Rndm*  rndmPtr;
+
+};
+//==========================================================================
+
+// The StringZ class is used to sample the fragmentation function f(z).
+
+class StringZ {
+
+public:
+
+  // Constructor. 
+  StringZ() {}
+
+  // Initialize data members.
+  void init(Settings& settings, ParticleData& particleData, Rndm* rndmPtrIn);
+  
+  // Fragmentation function: top-level to determine parameters.
+  double zFrag( int idOld, int idNew = 0, double mT2 = 1.);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const double CFROMUNITY, AFROMZERO, AFROMC, EXPMAX;
+
+  // Initialization data, to be read from Settings.
+  bool   usePetersonC, usePetersonB, usePetersonH;
+  double mc2, mb2, aLund, bLund, aExtraDiquark, rFactC, rFactB, rFactH, 
+         epsilonC, epsilonB, epsilonH;
+
+  // Fragmentation function: select z according to provided parameters.
+  double zLund( double a, double b, double c = 1.);
+  double zPeterson( double epsilon);
+
+  // Pointer to the random number generator.
+  Rndm*  rndmPtr;
+
+};
+//==========================================================================
+
+// The StringPT class is used to select select transverse momenta.
+
+class StringPT {
+
+public:
+
+  // Constructor. 
+  StringPT() {}
+
+  // Initialize data members.
+  void init(Settings& settings, Rndm* rndmPtrIn);
+
+  // Return px and py as a pair in the same call.
+  pair<double, double>  pxy();
+
+private: 
+
+  // Initialization data, to be read from Settings.
+  double sigmaQ, enhancedFraction, enhancedWidth;
+
+  // Pointer to the random number generator.
+  Rndm*  rndmPtr;
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_FragmentationFlavZpT_H
diff --git a/PYTHIA8/pythia8140/include/FragmentationSystems.h b/PYTHIA8/pythia8140/include/FragmentationSystems.h
new file mode 100644 (file)
index 0000000..b4a3073
--- /dev/null
@@ -0,0 +1,190 @@
+// FragmentationSystems.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains auxiliary classes in the fragmentation process.
+// ColSinglet contains info on an individual singlet.
+// ColConfig describes the colour configuration of the whole event.
+// StringRegion keeps track on string momenta and directions.
+// StringSystem contains all the StringRegions of the colour singlet.
+
+#ifndef Pythia8_FragmentationSystems_H
+#define Pythia8_FragmentationSystems_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The ColSinglet class contains info on an individual singlet.
+// Only to be used inside ColConfig, so no private members. 
+
+class ColSinglet {
+  
+public:
+
+  // Constructors.
+  ColSinglet() : pSum(0., 0., 0., 0.), mass(0.), massExcess(0.), 
+    hasJunction(false), isClosed(false), isCollected(false) {}
+  ColSinglet(vector<int>& iPartonIn, Vec4 pSumIn, double massIn, 
+    double massExcessIn, bool hasJunctionIn = false,
+    bool isClosedIn = false, bool isCollectedIn = false) 
+    : iParton(iPartonIn), pSum(pSumIn), mass(massIn), 
+    massExcess(massExcessIn), hasJunction(hasJunctionIn),
+    isClosed(isClosedIn), isCollected(isCollectedIn) {}
+
+  // Size of iParton array.
+  int size() const { return iParton.size();}
+
+  // Stored quantities. 
+  vector<int> iParton;
+  Vec4   pSum;
+  double mass, massExcess;
+  bool   hasJunction, isClosed, isCollected;
+  
+};
+//==========================================================================
+
+// The ColConfig class describes the colour configuration of the whole event. 
+
+class ColConfig {
+
+public:
+
+  // Constructor.
+  ColConfig() {singlets.resize(0);}
+
+  // Initialize and save pointers.
+  void init(Info* infoPtrIn, Settings& settings, StringFlav* flavSelPtrIn);
+
+  // Number of colour singlets.
+  int size() const {return singlets.size();}
+
+  // Overload index operator to access separate colour singlets.
+  ColSinglet& operator[](int iSub) {return singlets[iSub];}
+
+  // Clear contents.
+  void clear() {singlets.resize(0);} 
+
+  // Insert a new colour singlet system in ascending mass order. 
+  // Calculate its properties. Join nearby partons.
+  bool insert( vector<int>& iPartonIn, Event& event); 
+
+  // Collect all partons of singlet to be consecutively ordered.
+  void collect(int iSub, Event& event); 
+
+  // List all currently identified singlets.
+  void list(ostream& os = cout) const;
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double CONSTITUENTMASS;
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // Pointer to class for flavour generation.
+  StringFlav* flavSelPtr;
+
+  // Initialization data, to be read from Settings.
+  double mJoin, mJoinJunction, mStringMin;
+  // List of all separate colour singlets.
+  vector<ColSinglet> singlets;
+
+  // Join two legs of junction to a diquark for small invariant masses.
+  bool joinJunction( vector<int>& iPartonIn, Event& event, 
+    double massExcessIn); 
+
+};
+//==========================================================================
+
+// The StringRegion class contains the information related to 
+// one string section in the evolution of a multiparton system. 
+// Only to be used inside StringFragmentation and MiniStringFragmentation,
+// so no private members.
+
+class StringRegion {
+
+public:
+
+  // Constructor. 
+  StringRegion() : isSetUp(false), isEmpty(true) {}
+
+  // Constants: could only be changed in the code itself.
+  static const double MJOIN, TINY;
+
+  // Data members.
+  bool   isSetUp, isEmpty;
+  Vec4   pPos, pNeg, eX, eY;
+  double w2, xPosProj, xNegProj, pxProj, pyProj;
+
+  // Set up four-vectors for longitudinal and transverse directions.
+  void setUp(Vec4 p1, Vec4 p2, bool isMassless = false);
+
+  // Construct a four-momentum from (x+, x-, px, py).
+  Vec4 pHad( double xPosIn, double xNegIn, double pxIn, double pyIn) 
+    { return xPosIn * pPos + xNegIn * pNeg + pxIn * eX + pyIn * eY; }
+
+  // Project a four-momentum onto (x+, x-, px, py). Read out projection.
+  void project(Vec4 pIn);
+  void project( double pxIn, double pyIn, double pzIn, double eIn) 
+    { project( Vec4( pxIn, pyIn, pzIn, eIn) ); }
+  double xPos() const {return xPosProj;} 
+  double xNeg() const {return xNegProj;} 
+  double px() const {return pxProj;} 
+  double py() const {return pyProj;} 
+
+};
+//==========================================================================
+
+// The StringSystem class contains the complete set of all string regions.
+// Only to be used inside StringFragmentation, so no private members.
+
+class StringSystem {
+
+public:
+
+  // Constructor. 
+  StringSystem() {}
+
+  // Set up system from parton list.
+  void setUp(vector<int>& iSys, Event& event);
+
+  // Calculate string region from (iPos, iNeg) pair.
+  int iReg( int iPos, int iNeg) const 
+    {return (iPos * (indxReg - iPos)) / 2 + iNeg;}
+
+  // Reference to string region specified by (iPos, iNeg) pair.
+  StringRegion& region(int iPos, int iNeg) {return system[iReg(iPos, iNeg)];} 
+
+  // Reference to low string region specified either by iPos or iNeg.
+  StringRegion& regionLowPos(int iPos) {return system[iReg(iPos, iMax - iPos)];} 
+  StringRegion& regionLowNeg(int iNeg) {return system[iReg(iMax - iNeg, iNeg)];} 
+
+  // Main content: a vector with all the string regions of the system. 
+  vector<StringRegion> system;
+
+  // Other data members.
+  int    sizePartons, sizeStrings, sizeRegions, indxReg, iMax; 
+  double mJoin, m2Join;
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_FragmentationSystems_H
diff --git a/PYTHIA8/pythia8140/include/HadronLevel.h b/PYTHIA8/pythia8140/include/HadronLevel.h
new file mode 100644 (file)
index 0000000..bbbed48
--- /dev/null
@@ -0,0 +1,116 @@
+// HadronLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main class for hadron-level generation.
+// HadronLevel: handles administration of fragmentation and decay.
+
+#ifndef Pythia8_HadronLevel_H
+#define Pythia8_HadronLevel_H
+
+#include "Basics.h"
+#include "BoseEinstein.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "FragmentationSystems.h"
+#include "Info.h"
+#include "MiniStringFragmentation.h"
+#include "ParticleData.h"
+#include "ParticleDecays.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+#include "StringFragmentation.h"
+#include "TimeShower.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The HadronLevel class contains the top-level routines to generate
+// the transition from the partonic to the hadronic stage of an event.
+
+class HadronLevel {
+
+public:
+
+  // Constructor. 
+  HadronLevel() {}
+
+  // Initialize HadronLevel classes as required.
+  bool init(Info* infoPtrIn, Settings& settings, ParticleData& particleData,
+    Rndm* rndmPtrIn, TimeShower* timesDecPtr, DecayHandler* decayHandlePtr, 
+    vector<int> handledParticles);
+
+  // Get pointer to StringFlav instance (needed by BeamParticle).
+  StringFlav* getStringFlavPtr() {return &flavSel;}
+  // Generate the next event.
+  bool next(Event& event); 
+
+  // Special routine to allow more decays if on/off switches changed.
+  bool moreDecays(Event& event);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NTRYJNREST;
+  static const double JJSTRINGM2MAX, JJSTRINGM2FRAC, CONVJNREST, MTHAD;
+
+  // Initialization data, read from Settings.
+  bool   doHadronize, doDecay, doBoseEinstein;
+  double mStringMin, eNormJunction, widthSepBE;
+
+  // Pointer to various information on the generation.
+  Info*     infoPtr;
+
+  // Pointer to the random number generator.
+  Rndm*     rndmPtr;
+
+  // Configuration of colour-singlet systems.
+  ColConfig colConfig;   
+
+  // Colour information.
+  vector<int>    iColEnd, iAcolEnd, iColAndAcol, iParton, iPartonJun, 
+                 iPartonAntiJun, iJunLegA, iJunLegB, iJunLegC,  
+                 iAntiLegA, iAntiLegB, iAntiLegC, iGluLeg;
+  vector<double> m2Pair; 
+
+  // The generator class for normal string fragmentation.
+  StringFragmentation stringFrag;
+
+  // The generator class for special low-mass string fragmentation.
+  MiniStringFragmentation ministringFrag;
+
+  // The generator class for normal decays.
+  ParticleDecays decays;
+
+  // The generator class for Bose-Einstein effects. 
+  BoseEinstein boseEinstein;
+
+  // Classes for flavour, pT and z generation.
+  StringFlav flavSel;
+  StringPT   pTSel;
+  StringZ    zSel;
+
+  // Special case: colour-octet onium decays, to be done initially.
+  bool decayOctetOnia(Event& event);
+  // Trace colour flow in the event to form colour singlet subsystems.
+  bool findSinglets(Event& event);
+  // Trace a colour line, from a colour, from an anticolour, or in loop.
+  bool traceFromCol(int indxCol, Event& event, int iJun = -1, int iCol = -1);
+  bool traceFromAcol(int indxCol, Event& event, int iJun = -1, int iCol = -1); 
+  bool traceInLoop(int indxCol, int indxAcol, Event& event);
+
+  // Split junction-antijunction system into two, or simplify other way.
+  bool splitJunctionPair(Event& event);
+  
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_HadronLevel_H
diff --git a/PYTHIA8/pythia8140/include/HepMCInterface.h b/PYTHIA8/pythia8140/include/HepMCInterface.h
new file mode 100644 (file)
index 0000000..6367484
--- /dev/null
@@ -0,0 +1,105 @@
+// HepMCInterface.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Mikhail Kirsanov, Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for I_Pythia8 class,
+// which converts a PYTHIA event record to the standard HepMC format.
+
+#ifndef Pythia8_HepMCInterface_H
+#define Pythia8_HepMCInterface_H
+
+#include <set>
+#include <vector>
+#include "HepMC/IO_BaseClass.h"
+#include "Pythia.h"
+
+namespace HepMC {
+
+  class GenEvent;
+  class GenVertex;
+  class GenParticle;
+  class ParticleDataTable;
+
+//==========================================================================
+
+  class I_Pythia8 : public IO_BaseClass {
+    public:
+                        I_Pythia8();
+      virtual           ~I_Pythia8();
+      bool              fill_next_event( Pythia8::Event& pyev, GenEvent* evt,
+                                         int ievnum = -1 );
+      bool              fill_next_event( Pythia8::Pythia& pythia, GenEvent* evt,
+                                         int ievnum = -1,
+                                         bool convertGluonTo0 = false );
+      void              put_pdf_info( GenEvent* evt, Pythia8::Pythia& pythia,
+                                      bool convertGluonTo0 = false );
+
+      // See comments below for these switches.
+      bool              trust_both_mothers_and_daughters() const;
+      bool              trust_mothers_before_daughters() const;
+      bool              print_inconsistency_errors() const;
+      void              set_trust_mothers_before_daughters( bool b = 1 );
+      void              set_trust_both_mothers_and_daughters( bool b = 0 );
+      void              set_print_inconsistency_errors( bool b = 1 );
+      void              set_crash_on_problem( bool b = 1 );
+      void              set_convert_to_mev( bool b = 1 );
+      void              set_nofreepartonwarnings( bool b = 0 );
+
+    private: // following are not (yet?) implemented for this class
+      virtual bool fill_next_event( GenEvent*  ) { return 0; }
+      virtual void write_event( const GenEvent* ) {;}
+      virtual void write_particle_data_table( const ParticleDataTable* ){}
+      virtual bool fill_particle_data_table( ParticleDataTable* )
+        { return 0; }
+
+    private: // use of copy constructor is not allowed
+      I_Pythia8( const I_Pythia8& ) : IO_BaseClass() {}
+
+    private: // data members
+
+      bool m_trust_mothers_before_daughters;
+      bool m_trust_both_mothers_and_daughters;
+      bool m_print_inconsistency_errors; 
+      int m_internal_event_number;
+      bool m_crash_on_problem;
+      bool m_convert_to_mev;
+      float m_mom_scale_factor;
+      bool m_freepartonwarnings;
+
+  };
+
+  // INLINES access methods.
+
+  inline bool I_Pythia8::trust_both_mothers_and_daughters() const 
+  { return m_trust_both_mothers_and_daughters; }
+    
+  inline bool I_Pythia8::trust_mothers_before_daughters() const 
+  { return m_trust_mothers_before_daughters; }
+
+  inline bool I_Pythia8::print_inconsistency_errors() const
+  { return m_print_inconsistency_errors; }
+  inline void I_Pythia8::set_trust_both_mothers_and_daughters( bool b )
+  { m_trust_both_mothers_and_daughters = b; }
+
+  inline void I_Pythia8::set_trust_mothers_before_daughters( bool b )
+  { m_trust_mothers_before_daughters = b; }
+
+  inline void I_Pythia8::set_print_inconsistency_errors( bool b  )
+  { m_print_inconsistency_errors = b; }
+
+  inline void I_Pythia8::set_crash_on_problem( bool b  )
+  { m_crash_on_problem = b; }
+
+  inline void I_Pythia8::set_convert_to_mev( bool b  )
+  { m_convert_to_mev = b; m_mom_scale_factor = 1000.; }
+
+  inline void I_Pythia8::set_nofreepartonwarnings( bool b  )
+  { m_freepartonwarnings = b; }
+
+//==========================================================================
+
+} // end namespace HepMC
+
+#endif  // end Pythia8_HepMCInterface_H
diff --git a/PYTHIA8/pythia8140/include/Info.h b/PYTHIA8/pythia8140/include/Info.h
new file mode 100644 (file)
index 0000000..d61b5c6
--- /dev/null
@@ -0,0 +1,284 @@
+// Info.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains a class that keep track of generic event info.
+// Info: contains information on the generation process and errors.
+
+#ifndef Pythia8_Info_H
+#define Pythia8_Info_H
+
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The Info class contains a mixed bag of information on the event
+// generation activity, especially on the current subprocess properties,
+// and on the number of errors encountered. This is used by the 
+// generation machinery, but can also be read by the user.
+// Note: some methods that maybe should not be accessible to the user
+// are still public, to work also for user-written FSR/ISR classes.
+
+class Info {
+
+public:
+
+  // Constructor. 
+  Info() {lowPTmin = false; for (int i = 0; i < 40; ++i) counters[i] = 0;} 
+
+  // Listing of most available information on current event.
+  void   list(ostream& os = cout) const;
+  
+  // Beam particles (in rest frame). CM energy of event.
+  int    idA()            const {return idASave;}
+  int    idB()            const {return idBSave;}
+  double pzA()            const {return pzASave;}
+  double pzB()            const {return pzBSave;}
+  double eA()             const {return eASave;}
+  double eB()             const {return eBSave;}
+  double mA()             const {return mASave;}
+  double mB()             const {return mBSave;}
+  double eCM()            const {return eCMSave;}
+  double s()              const {return sSave;}
+
+  // Warnings from initialization.
+  bool   tooLowPTmin()    const {return lowPTmin;}
+
+  // Process name and code, and the number of final-state particles.
+  string name()           const {return nameSave;}
+  int    code()           const {return codeSave;}    
+  int    nFinal()         const {return nFinalSave;}
+
+  // Are beam particles resolved, with pdf's? Are they diffractive? 
+  bool   isResolved()     const {return isRes;}
+  bool   isDiffractiveA() const {return isDiffA;} 
+  bool   isDiffractiveB() const {return isDiffB;} 
+  bool   isMinBias()      const {return isMB;}
+
+  // Information for Les Houches Accord and reading files.
+  bool   isLHA()          const {return isLH;}
+  bool   atEndOfFile()    const {return atEOF;}
+
+  // For minbias and Les Houches Accord identify hardest subprocess.
+  bool   hasSub()         const {return hasSubSave;}
+  string nameSub()        const {return nameSubSave;}
+  int    codeSub()        const {return codeSubSave;}    
+  int    nFinalSub()      const {return nFinalSubSave;}
+
+  // Incoming parton flavours and x values.
+  int    id1()            const {return id1Save;}
+  int    id2()            const {return id2Save;}
+  double x1()             const {return x1Save;}
+  double x2()             const {return x2Save;}
+  double y()              const {return 0.5 * log( x1Save / x2Save );}
+  double tau()            const {return x1Save * x2Save;}
+
+  // Incoming parton densities, hard process couplings, Q2 scales.
+  double pdf1()           const {return pdf1Save;}
+  double pdf2()           const {return pdf2Save;}
+  double QFac()           const {return sqrtpos(Q2FacSave);}
+  double Q2Fac()          const {return Q2FacSave;}
+  bool   isValence1()     const {return isVal1;}
+  bool   isValence2()     const {return isVal2;}
+  double alphaS()         const {return alphaSSave;}
+  double alphaEM()        const {return alphaEMSave;}
+  double QRen()           const {return sqrtpos(Q2RenSave);}
+  double Q2Ren()          const {return Q2RenSave;}
+
+  // Mandelstam variables (notation as if subcollision).
+  double mHat()           const {return sqrt(sH);}   
+  double sHat()           const {return sH;}   
+  double tHat()           const {return tH;}   
+  double uHat()           const {return uH;}   
+  double pTHat()          const {return pTH;} 
+  double pT2Hat()         const {return pTH*pTH;} 
+  double m3Hat()          const {return m3H;}   
+  double m4Hat()          const {return m4H;} 
+  double thetaHat()       const {return thetaH;}   
+  double phiHat()         const {return phiH;}   
+
+  // Weight of current event; normally 1, but used for Les Houches events.
+  double weight()         const {return weightSave;}   
+
+  // Number of times other steps have been carried out.
+  int    nISR()           const {return nISRSave;}
+  int    nFSRinProc()     const {return nFSRinProcSave;}
+  int    nFSRinRes()      const {return nFSRinResSave;}
+
+  // Maximum pT scales for MI, ISR and FSR (in hard process).
+  double pTmaxMI()        const {return pTmaxMISave;}
+  double pTmaxISR()       const {return pTmaxISRSave;}
+  double pTmaxFSR()       const {return pTmaxFSRSave;}
+
+  // Current evolution scale (for UserHooks).
+  double pTnow()          const {return pTnowSave;}
+
+  // Impact parameter picture.
+  double bMI()            const {return (bIsSet) ? bMISave : 1.;}
+  double enhanceMI()      const {return (bIsSet) ? enhanceMISave : 1.;}
+
+  // Number of multiple interactions, with code and pT for them.
+  int    nMI()            const {return nMISave;}
+  int    codeMI(int i)    const {return codeMISave[i];} 
+  double pTMI(int i)      const {return pTMISave[i];} 
+  int    iAMI(int i)      const {return iAMISave[i];} 
+  int    iBMI(int i)      const {return iBMISave[i];} 
+
+  // Cross section estimate.
+  long   nTried()         const {return nTry;}
+  long   nSelected()      const {return nSel;}
+  long   nAccepted()      const {return nAcc;}
+  double sigmaGen()       const {return sigGen;}
+  double sigmaErr()       const {return sigErr;}
+
+  // Counters for number of loops in various places.
+  int    getCounter( int i)  const {return counters[i];}    
+
+  // Set or increase the value stored in a counter.
+  void   setCounter( int i, int value = 0) {counters[i]  = value;}
+  void   addCounter( int i, int value = 1) {counters[i] += value;}
+
+  // Reset to empty map of error messages.
+  void   errorReset() {messages.clear();}
+  
+  // Print a message the first few times. Insert in database.
+  void   errorMsg(string messageIn, string extraIn = " ", 
+    bool showAlways = false, ostream& os = cout);
+
+  // Provide total number of errors/aborts/warnings experienced to date.
+  int    errorTotalNumber();
+
+  // Print statistics on errors/aborts/warnings.
+  void   errorStatistics(ostream& os = cout);
+
+  // Set initialization warning flag when too low pTmin in ISR/FSR/MI.
+  void   setTooLowPTmin(bool lowPTminIn) {lowPTmin = lowPTminIn;} 
+
+private:
+
+  // Number of times the same error message is repeated, unless overridden.
+  static const int TIMESTOPRINT;
+
+  // Store common beam quantities. 
+  int    idASave, idBSave;
+  double pzASave, eASave,mASave, pzBSave, eBSave, mBSave, eCMSave, sSave;
+
+  // Store initialization information.
+  bool   lowPTmin;
+
+  // Store common integrated cross section quantities.
+  long   nTry, nSel, nAcc;
+  double sigGen, sigErr;
+
+  // Store current-event quantities.
+  bool   isRes, isDiffA, isDiffB, isMB, isLH, hasSubSave, bIsSet, evolIsSet,
+         atEOF, isVal1, isVal2;  
+  int    codeSave, codeSubSave, nFinalSave, nFinalSubSave, nTotal, 
+         id1Save, id2Save, nMISave, nISRSave, nFSRinProcSave, nFSRinResSave;
+  double x1Save, x2Save, pdf1Save, pdf2Save, Q2FacSave, alphaEMSave, 
+         alphaSSave, Q2RenSave, sH, tH, uH, pTH, m3H, m4H, thetaH, phiH, 
+         weightSave, bMISave, enhanceMISave, pTmaxMISave, pTmaxISRSave, 
+         pTmaxFSRSave, pTnowSave;
+  string nameSave, nameSubSave;
+  vector<int>    codeMISave, iAMISave, iBMISave;
+  vector<double> pTMISave;
+
+  // Vector of various loop counters.
+  int    counters[50];
+
+  // Map for all error messages.
+  map<string, int> messages;
+
+  // Friend classes allowed to set info.
+  friend class Pythia;
+  friend class ProcessLevel;
+  friend class ProcessContainer;
+  friend class PartonLevel;
+  friend class MultipleInteractions;
+
+  // Set info on the two incoming beams: only from Pythia class.
+  void setBeamA( int idAin, double pzAin, double eAin, double mAin) {
+    idASave = idAin; pzASave = pzAin; eASave = eAin; mASave = mAin;}
+  void setBeamB( int idBin, double pzBin, double eBin, double mBin) {
+    idBSave = idBin; pzBSave = pzBin; eBSave = eBin; mBSave = mBin;}
+  void setECM( double eCMin) {eCMSave = eCMin; sSave = eCMSave * eCMSave;}
+
+  // Reset info for current event: only from Pythia class.
+  void clear() { isRes = isDiffA = isDiffB = isMB = isLH = atEOF = bIsSet 
+    = isVal1 =isVal2 = false; codeSave = nFinalSave = nTotal = id1Save 
+    = id2Save = nMISave = nISRSave = nFSRinProcSave = nFSRinResSave = 0; 
+    x1Save = x2Save = pdf1Save = pdf2Save = Q2FacSave = alphaEMSave 
+    = alphaSSave = Q2RenSave = sH = tH = uH = pTH = m3H = m4H = thetaH 
+    = phiH = 0.; nameSave = " "; weightSave = bMISave = enhanceMISave = 1.; 
+    codeMISave.resize(0); pTMISave.resize(0); iAMISave.resize(0);
+    iBMISave.resize(0); }
+
+  // Set info on the (sub)process: from ProcessLevel, ProcessContainer or 
+  // MultipleInteractions classes.
+  void setType( string nameIn, int codeIn, int nFinalIn,  
+    bool isMinBiasIn = false, bool isResolvedIn = true, 
+    bool isDiffractiveAin = false, bool isDiffractiveBin = false,
+    bool isLHAin = false) {nameSave = nameIn; codeSave = codeIn; 
+    nFinalSave = nFinalIn; isMB = isMinBiasIn; isRes = isResolvedIn; 
+    isDiffA = isDiffractiveAin; isDiffB = isDiffractiveBin; isLH = isLHAin;
+    nTotal = 2 + nFinalSave; bIsSet = false; hasSubSave = false; 
+    nameSubSave = " "; codeSubSave = 0; nFinalSubSave = 0; evolIsSet = false;}
+  void setSubType( string nameSubIn, int codeSubIn, int nFinalSubIn) {  
+    hasSubSave = true; nameSubSave = nameSubIn; codeSubSave = codeSubIn; 
+    nFinalSubSave = nFinalSubIn;}
+  void setPDFalpha( int id1In, int id2In,  double pdf1In, double pdf2In, 
+    double Q2FacIn, double alphaEMIn, double alphaSIn, double Q2RenIn) 
+    {id1Save = id1In; id2Save = id2In; pdf1Save = pdf1In; pdf2Save = pdf2In; 
+    Q2FacSave = Q2FacIn; alphaEMSave = alphaEMIn; alphaSSave = alphaSIn; 
+    Q2RenSave = Q2RenIn;}
+  void setKin( double x1In, double x2In, double sHatIn, double tHatIn, 
+    double uHatIn, double pTHatIn, double m3HatIn, double m4HatIn, 
+    double thetaHatIn, double phiHatIn) {x1Save = x1In; x2Save = x2In; 
+    sH = sHatIn; tH = tHatIn; uH = uHatIn; pTH = pTHatIn; m3H = m3HatIn; 
+    m4H = m4HatIn; thetaH = thetaHatIn; phiH = phiHatIn;}
+  void setTypeMI( int codeMIIn, double pTMIIn, int iAMIIn = 0, int iBMIIn = 0) {
+    codeMISave.push_back(codeMIIn); pTMISave.push_back(pTMIIn);
+    iAMISave.push_back(iAMIIn); iBMISave.push_back(iBMIIn);}
+
+  // Set info on cross section: from ProcessLevel.
+  void setSigma( long nTryIn, long nSelIn, long nAccIn, double sigGenIn, 
+    double sigErrIn) { nTry = nTryIn; nSel = nSelIn; nAcc = nAccIn; 
+    sigGen = sigGenIn; sigErr = sigErrIn;} 
+
+  // Set info on valence character of hard collision partons: from PartonLevel.
+  void setValence( bool isVal1In, bool isVal2In) {isVal1 = isVal1In; 
+    isVal2 = isVal2In;}
+
+  // Set info on impact parameter: from PartonLevel.
+  void setImpact( double bMIIn, double enhanceMIIn) {bMISave = bMIIn;
+    enhanceMISave = enhanceMIIn, bIsSet = true;} 
+
+  // Set info on pTmax scales and number of evolution steps: from PartonLevel.
+  void setPartEvolved( int nMIIn, int nISRIn) {
+    nMISave = nMIIn; nISRSave = nISRIn;} 
+  void setEvolution( double pTmaxMIIn, double pTmaxISRIn, double pTmaxFSRIn, 
+    int nMIIn, int nISRIn, int nFSRinProcIn, int nFSRinResIn) { 
+    pTmaxMISave = pTmaxMIIn; pTmaxISRSave = pTmaxISRIn; 
+    pTmaxFSRSave = pTmaxFSRIn; nMISave = nMIIn; nISRSave = nISRIn; 
+    nFSRinProcSave = nFSRinProcIn; nFSRinResSave = nFSRinResIn; 
+    evolIsSet = true;}
+
+  // Set current pT evolution scale for MI/ISR/FSR; from PartonLevel.
+  void setPTnow( double pTnowIn) {pTnowSave = pTnowIn;}
+
+  // Set info whether reading of Les Houches Accord file at end.
+  void setEndOfFile( bool atEOFin) {atEOF = atEOFin;}
+
+  // Set event weight; currently only for Les Houches description.
+  void setWeight( double weightIn) {weightSave = weightIn;}
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_Info_H
diff --git a/PYTHIA8/pythia8140/include/LHAFortran.h b/PYTHIA8/pythia8140/include/LHAFortran.h
new file mode 100644 (file)
index 0000000..05ee997
--- /dev/null
@@ -0,0 +1,119 @@
+// LHAFortran.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for Fortran Les Houches Accord user process information.
+// LHAupFortran: derived class with the HEPRUP and HEPEUP Fortran info.
+// You are expected to supply the fillHepRup and fillHepEup methods.
+
+#ifndef Pythia8_LHAFortran_H
+#define Pythia8_LHAFortran_H
+
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Give access to the HEPRUP and HEPEUP Fortran commonblocks.
+
+#ifdef _WIN32
+  #define heprup_ HEPRUP
+  #define hepeup_ HEPEUP
+#endif
+
+extern "C" {
+
+  extern struct {
+    int idbmup[2];
+    double ebmup[2];
+    int pdfgup[2], pdfsup[2], idwtup, nprup;
+    double xsecup[100], xerrup[100], xmaxup[100];
+    int lprup[100];
+  } heprup_;
+
+  extern struct {
+    int nup, idprup;
+    double xwgtup, scalup, aqedup, aqcdup;
+    int idup[500], istup[500], mothup[500][2], icolup[500][2];
+    double pup[500][5], vtimup[500],spinup[500];
+  } hepeup_;
+
+}
+
+//==========================================================================
+
+// A derived class with initialization information from the HEPRUP 
+// Fortran commonblock and event information from the HEPEUP one.
+
+class LHAupFortran : public LHAup {
+
+public:
+
+  // Constructor.
+  LHAupFortran() {}
+
+  // Routine for doing the job of setting initialization info.  
+  bool setInit() {
+    // Call the routine that does the job.
+    if (!fillHepRup()) return false;
+    // Store beam and strategy info. 
+    setBeamA(heprup_.idbmup[0], heprup_.ebmup[0], heprup_.pdfgup[0], 
+      heprup_.pdfsup[0]);
+    setBeamB(heprup_.idbmup[1], heprup_.ebmup[1], heprup_.pdfgup[1], 
+      heprup_.pdfsup[1]);
+    setStrategy(heprup_.idwtup);
+    // Store process info. Protect against vanishing cross section.
+    for (int ip = 0; ip < heprup_.nprup; ++ip) {
+      double xsec = max( 1e-10, heprup_.xsecup[ip]);
+      addProcess( heprup_.lprup[ip], xsec, heprup_.xerrup[ip], 
+        heprup_.xmaxup[ip] );
+    }
+    // Store the beam energies to calculate x values later.
+    eBeamA = heprup_.ebmup[0];
+    eBeamB = heprup_.ebmup[1];    
+    // Done.
+    return true;
+  } 
+
+  // Routine for doing the job of setting info on next event.  
+  bool setEvent(int idProcIn = 0) {
+    // In some strategies the type of the next event has been set.
+    hepeup_.idprup = idProcIn;
+    // Call the routine that does the job.
+    if (!fillHepEup()) return false;
+    // Store process info.
+    setProcess(hepeup_.idprup, hepeup_.xwgtup, hepeup_.scalup, 
+      hepeup_.aqedup, hepeup_.aqcdup);
+    // Store particle info.
+    for (int ip = 0; ip < hepeup_.nup; ++ip) addParticle(hepeup_.idup[ip], 
+      hepeup_.istup[ip], hepeup_.mothup[ip][0], hepeup_.mothup[ip][1], 
+      hepeup_.icolup[ip][0], hepeup_.icolup[ip][1], hepeup_.pup[ip][0], 
+      hepeup_.pup[ip][1], hepeup_.pup[ip][2], hepeup_.pup[ip][3], 
+      hepeup_.pup[ip][4], hepeup_.vtimup[ip], hepeup_.spinup[ip]) ;
+    // Store x values (here E = pup[ip][3]), but note incomplete info.
+    setPdf( hepeup_.idup[0], hepeup_.idup[1], hepeup_.pup[0][3]/eBeamA, 
+           hepeup_.pup[1][3]/eBeamB, 0., 0., 0., false);
+    // Done.
+    return true;
+  }
+
+private:
+
+  // Save beam energies to calculate x values.
+  double eBeamA, eBeamB;
+
+  // User-written routine that does the intialization and fills heprup.
+  bool fillHepRup();
+
+  // User-written routine that does the event generation and fills hepeup.
+  bool fillHepEup();
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_LHAFortran_H
diff --git a/PYTHIA8/pythia8140/include/LHAPDFInterface.h b/PYTHIA8/pythia8140/include/LHAPDFInterface.h
new file mode 100644 (file)
index 0000000..761468b
--- /dev/null
@@ -0,0 +1,83 @@
+// LHAPDFInterface.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for the LHAPDF f77 external linkage to C++.
+// All required code is contained here, i.e. there is no matching .cc file.
+
+#ifndef Pythia8_LHAPDFInterface_H
+#define Pythia8_LHAPDFInterface_H
+
+namespace Pythia8 {
+//==========================================================================
+
+// Declare the LHAPDF f77 subroutines that are needed.
+
+extern "C" {
+
+  extern void initpdfsetm_(int&, const char*, int);
+
+  extern void initpdfsetbynamem_(int&, const char*, int);
+
+  extern void initpdfm_(int&, int&);
+
+  extern void evolvepdfm_(int&, double&, double&, double*);
+
+  extern void evolvepdfphotonm_(int&, double&, double&, double*, double&);
+
+  extern void setlhaparm_(const char*, int);
+    
+}
+
+//==========================================================================
+
+// Interfaces to the above routines, to make the C++ calls similar to f77.
+
+class LHAPDFInterface {
+
+public:
+
+  // Initialize set with full pathname, allowing multiple sets.
+  static void initPDFsetM( int& nSet, string name) {
+    const char* cName = name.c_str(); int lenName = name.length();
+    initpdfsetm_( nSet, cName, lenName);
+  }
+
+  // Initialize set with simple name, allowing multiple sets.
+  static void initPDFsetByNameM( int& nSet, string name) {
+    const char* cName = name.c_str(); int lenName = name.length();
+    initpdfsetbynamem_( nSet, cName, lenName);
+  }
+
+  // Initialize member of set.
+  static void initPDFM(int& nSet, int member) {
+    initpdfm_(nSet, member);
+  }
+
+  // Evaluate x f_i(x, Q).
+  static void evolvePDFM( int& nSet, double x, double Q, double* xfArray) {
+    evolvepdfm_( nSet, x, Q, xfArray);
+  }
+
+  // Evaluate x f_i(x, Q) including photon
+  static void evolvePDFPHOTONM( int& nSet, double x, double Q, 
+                               double* xfArray, double& xPhoton) {
+    evolvepdfphotonm_( nSet, x, Q, xfArray, xPhoton);
+  }
+
+  // Extrapolate PDF set beyond boundaries, or freeze them there.
+  static void setPDFparm(string name) {  
+    const char* cName = name.c_str(); int lenName = name.length();
+    setlhaparm_( cName, lenName);
+  }
+  
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_LHAPDFInterface_H
diff --git a/PYTHIA8/pythia8140/include/LesHouches.h b/PYTHIA8/pythia8140/include/LesHouches.h
new file mode 100644 (file)
index 0000000..800f448
--- /dev/null
@@ -0,0 +1,347 @@
+// LesHouches.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for Les Houches Accord user process information.
+// LHAProcess: stores a single process; used by the other classes.
+// LHAParticle: stores a single particle; used by the other classes.
+// LHAup: base class for initialization and event information.
+// LHAupLHEF: derived class for reading from an Les Houches Event File.
+// Code for interfacing with Fortran commonblocks is found in LHAFortran.h.
+
+#ifndef Pythia8_LesHouches_H
+#define Pythia8_LesHouches_H
+
+#include "Event.h"
+#include "Info.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// A class for the processes stored in LHAup.
+  
+class LHAProcess {
+
+public:
+
+  // Constructors.
+  LHAProcess() : idProc(0), xSecProc(0.), xErrProc(0.), xMaxProc(0.) { }
+  LHAProcess(int idProcIn, double xSecIn, double xErrIn, double xMaxIn) :
+    idProc(idProcIn), xSecProc(xSecIn), xErrProc(xErrIn), 
+    xMaxProc(xMaxIn) { }
+
+  // Process properties.
+  int idProc;
+  double xSecProc, xErrProc, xMaxProc;
+
+} ;
+
+//==========================================================================
+
+// A class for the particles stored in LHAup.
+
+class LHAParticle {
+
+public:
+
+  // Constructors.   
+  LHAParticle() : idPart(0), statusPart(0), mother1Part(0), 
+    mother2Part(0), col1Part(0), col2Part(0), pxPart(0.), pyPart(0.), 
+    pzPart(0.), ePart(0.), mPart(0.), tauPart(0.), spinPart(9.) { }
+  LHAParticle(int idIn, int statusIn, int mother1In, int mother2In,
+    int col1In, int col2In, double pxIn, double pyIn, double pzIn, 
+    double eIn, double mIn, double tauIn, double spinIn) :
+    idPart(idIn), statusPart(statusIn), mother1Part(mother1In), 
+    mother2Part(mother2In), col1Part(col1In), col2Part(col2In), 
+    pxPart(pxIn), pyPart(pyIn), pzPart(pzIn), ePart(eIn), mPart(mIn), 
+    tauPart(tauIn), spinPart(spinIn) { }
+
+  // Particle properties.    
+  int idPart, statusPart, mother1Part, mother2Part, col1Part, col2Part;
+  double pxPart, pyPart, pzPart, ePart, mPart, tauPart, spinPart;
+
+} ;
+
+//==========================================================================
+
+// LHAup is base class for initialization and event information 
+// from an external parton-level generator.
+
+class LHAup {
+
+public:
+
+  // Destructor.
+  virtual ~LHAup() {}
+
+  // Set info pointer.
+  void setPtr(Info* infoPtrIn) {infoPtr = infoPtrIn;}
+  // Method to be used for LHAupLHEF derived class.
+  virtual bool fileFound() {return true;} 
+  // A pure virtual method setInit, wherein all initialization information 
+  // is supposed to be set in the derived class. Can do this by reading a 
+  // file or some other way, as desired. Returns false if it did not work. 
+  virtual bool setInit() = 0; 
+
+  // Give back info on beams.
+  int    idBeamA()       const {return idBeamASave;}
+  int    idBeamB()       const {return idBeamBSave;}
+  double eBeamA()        const {return eBeamASave;}
+  double eBeamB()        const {return eBeamBSave;}
+  int    pdfGroupBeamA() const {return pdfGroupBeamASave;}
+  int    pdfGroupBeamB() const {return pdfGroupBeamBSave;}
+  int    pdfSetBeamA()   const {return pdfSetBeamASave;}
+  int    pdfSetBeamB()   const {return pdfSetBeamBSave;}
+    
+  // Give back weight strategy.
+  int    strategy()      const {return strategySave;}
+
+  // Give back info on processes.
+  int    sizeProc()      const {return processes.size();} 
+  int    idProcess(int proc) const {return processes[proc].idProc;} 
+  double xSec(int proc)  const {return processes[proc].xSecProc;}    
+  double xErr(int proc)  const {return processes[proc].xErrProc;}    
+  double xMax(int proc)  const {return processes[proc].xMaxProc;} 
+   
+  // Print the initialization info; useful to check that setting it worked.
+  void   listInit(ostream& os = cout);  
+
+  // A pure virtual method setEvent, wherein information on the next event
+  // is supposed to be set in the derived class. 
+  // Strategies +-1 and +-2: idProcIn is the process type, selected by PYTHIA.
+  // Strategies +-3 and +-4: idProcIn is dummy; process choice is made locally.
+  // The method can find the next event by a runtime interface to another
+  // program, or by reading a file, as desired. 
+  // The method should return false if it did not work.
+  virtual bool setEvent(int idProcIn = 0) = 0; 
+
+  // Give back process number, weight, scale, alpha_em, alpha_s.
+  int    idProcess()       const {return idProc;} 
+  double weight()          const {return weightProc;} 
+  double scale()           const {return scaleProc;} 
+  double alphaQED()        const {return alphaQEDProc;} 
+  double alphaQCD()        const {return alphaQCDProc;} 
+
+  // Give back info on separate particle.
+  int    sizePart()        const {return particles.size();}
+  int    id(int part)      const {return particles[part].idPart;}
+  int    status(int part)  const {return particles[part].statusPart;}
+  int    mother1(int part) const {return particles[part].mother1Part;}
+  int    mother2(int part) const {return particles[part].mother2Part;}
+  int    col1(int part)    const {return particles[part].col1Part;}
+  int    col2(int part)    const {return particles[part].col2Part;}
+  double px(int part)      const {return particles[part].pxPart;}
+  double py(int part)      const {return particles[part].pyPart;}
+  double pz(int part)      const {return particles[part].pzPart;}
+  double e(int part)       const {return particles[part].ePart;}
+  double m(int part)       const {return particles[part].mPart;}
+  double tau(int part)     const {return particles[part].tauPart;}
+  double spin(int part)    const {return particles[part].spinPart;}
+
+  // Optional: give back info on parton density values of event.
+  bool   pdfIsSet()        const {return pdfIsSetSave;}
+  int    id1()             const {return id1Save;}
+  int    id2()             const {return id2Save;}
+  double x1()              const {return x1Save;}
+  double x2()              const {return x2Save;}
+  double scalePDF()        const {return scalePDFSave;}
+  double xpdf1()           const {return xpdf1Save;}
+  double xpdf2()           const {return xpdf2Save;}
+
+  // Print the info; useful to check that reading an event worked.
+  void   listEvent(ostream& os = cout);  
+
+  // Skip ahead a number of events, which are not considered further.
+  // Mainly intended for debug when using the LHAupLHEF class.
+  virtual bool skipEvent(int nSkip) {
+    for (int iSkip = 0; iSkip < nSkip; ++iSkip)
+    if (!setEvent()) return false; return true;} 
+
+  // Four routines to write a Les Houches Event file in steps.
+  bool   openLHEF(string fileNameIn);
+  bool   initLHEF();
+  bool   eventLHEF();
+  bool   closeLHEF(bool updateInit = false);
+
+protected:
+
+  // Constructor. Sets default to be that events come with unit weight.
+  LHAup(int strategyIn = 3) : strategySave(strategyIn) 
+    { processes.reserve(10); particles.reserve(20); } 
+
+  // Allow conversion from mb to pb.
+  static const double CONVERTMB2PB;
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // Input beam info.
+  void setBeamA(int idIn, double eIn, int pdfGroupIn = 0, int pdfSetIn = 0) 
+    { idBeamASave = idIn; eBeamASave = eIn; pdfGroupBeamASave = pdfGroupIn;  
+    pdfSetBeamASave = pdfSetIn;} 
+  void setBeamB(int idIn, double eIn, int pdfGroupIn = 0, int pdfSetIn = 0) 
+    { idBeamBSave = idIn; eBeamBSave = eIn; pdfGroupBeamBSave = pdfGroupIn;  
+    pdfSetBeamBSave = pdfSetIn;} 
+
+  // Input process weight strategy.
+  void setStrategy(int strategyIn) {strategySave = strategyIn;} 
+
+  // Input process info.
+  void addProcess(int idProcIn, double xSecIn = 1., double xErrIn = 0., 
+    double xMaxIn = 1.) { processes.push_back( LHAProcess( idProcIn, 
+    xSecIn, xErrIn, xMaxIn)); }
+
+  // Possibility to update some cross section info at end of run.
+  void setXSec(int iP, double xSecIn) {processes[iP].xSecProc = xSecIn;}
+  void setXErr(int iP, double xErrIn) {processes[iP].xErrProc = xErrIn;}
+  void setXMax(int iP, double xMaxIn) {processes[iP].xMaxProc = xMaxIn;}     
+  // Input info on the selected process.
+  void setProcess(int idProcIn = 0, double weightIn = 1., double 
+    scaleIn = 0., double alphaQEDIn = 0.0073, double alphaQCDIn = 0.12) { 
+    idProc = idProcIn; weightProc = weightIn; scaleProc = scaleIn; 
+    alphaQEDProc = alphaQEDIn; alphaQCDProc = alphaQCDIn; 
+    // Clear particle list. Add empty zeroth particle for correct indices.
+    particles.clear(); addParticle(0); pdfIsSetSave = false;}
+
+  // Input particle info, one particle at the time.
+  void addParticle(LHAParticle particleIn) {
+    particles.push_back(particleIn);}
+  void addParticle(int idIn, int statusIn = 0, int mother1In = 0, 
+    int mother2In = 0, int col1In = 0, int col2In = 0, double pxIn = 0., 
+    double pyIn = 0., double pzIn = 0., double eIn = 0., double mIn = 0., 
+    double tauIn = 0., double spinIn = 9.) { 
+    particles.push_back( LHAParticle( idIn, statusIn, mother1In, mother2In, 
+    col1In, col2In, pxIn, pyIn, pzIn, eIn, mIn, tauIn, spinIn)); }
+
+  // Optionally input info on parton density values of event.
+  void setPdf(int id1In, int id2In, double x1In, double x2In, 
+    double scalePDFIn, double xpdf1In, double xpdf2In, bool pdfIsSetIn) 
+    { id1Save = id1In; id2Save = id2In; x1Save = x1In; x2Save = x2In;
+    scalePDFSave = scalePDFIn; xpdf1Save = xpdf1In; xpdf2Save = xpdf2In;
+    pdfIsSetSave = pdfIsSetIn;}
+
+  // Three routines for LHEF files, but put here for flexibility.
+  bool setInitLHEF(ifstream& is);
+  bool setNewEventLHEF(ifstream& is);
+  bool setOldEventLHEF();
+
+  // Event properties from LHEF files, for repeated use.
+  int    nupSave, idprupSave;
+  double xwgtupSave, scalupSave, aqedupSave, aqcdupSave;
+  vector<LHAParticle> particlesSave;
+  bool   getPDFSave;
+  int    id1InSave, id2InSave;
+  double x1InSave, x2InSave, scalePDFInSave, xpdf1InSave, xpdf2InSave;
+
+private:
+
+  // Event weighting and mixing strategy.
+  int strategySave;
+
+  // Beam particle properties.
+  int idBeamASave, idBeamBSave;
+  double eBeamASave, eBeamBSave;
+  int pdfGroupBeamASave, pdfGroupBeamBSave, pdfSetBeamASave, pdfSetBeamBSave;
+
+  // The process list, stored as a vector of processes.
+  vector<LHAProcess> processes;
+
+  // Store info on the selected process. 
+  int idProc;
+  double weightProc, scaleProc, alphaQEDProc, alphaQCDProc;
+
+  // The particle list, stored as a vector of particles.
+  vector<LHAParticle> particles;
+
+  // Optional info on parton density values of event.
+  bool   pdfIsSetSave;
+  int    id1Save, id2Save;
+  double x1Save, x2Save, scalePDFSave, xpdf1Save, xpdf2Save;
+  // File to which to write Les Houches Event File information.
+  string fileName;
+  fstream osLHEF;
+  char dateNow[12];
+  char timeNow[9];
+
+};
+
+//==========================================================================
+
+// A derived class with information read from a Les Houches Event File.
+
+class LHAupLHEF : public LHAup {
+
+public:
+
+  // Constructor.
+  LHAupLHEF(const char* fileIn) : is(fileIn) {}
+
+  // Destructor.
+  ~LHAupLHEF() {}
+
+  // Confirm that file was found and opened as expected.
+  bool fileFound() {return is.good();} 
+
+  // Routine for doing the job of reading and setting initialization info.  
+  bool setInit() {return setInitLHEF(is);} 
+
+  // Routine for doing the job of reading and setting info on next event.  
+  bool setEvent(int = 0) {if (!setNewEventLHEF(is)) return false;
+    return setOldEventLHEF();} 
+
+  // Skip ahead a number of events, which are not considered further.
+  bool skipEvent(int nSkip) {for (int iSkip = 0; iSkip < nSkip; ++iSkip)
+    if (!setNewEventLHEF(is)) return false; return true;} 
+
+private:
+  // File from which to read.
+  ifstream is;
+
+};
+
+//==========================================================================
+
+// A derived class with information read from PYTHIA 8 itself, for output.
+
+class LHAupFromPYTHIA8 : public LHAup {
+
+public:
+
+  // Constructor.
+  LHAupFromPYTHIA8(Event* processPtrIn, Info* infoPtrIn) {
+    processPtr = processPtrIn; infoPtr = infoPtrIn;}
+
+  // Destructor.
+  ~LHAupFromPYTHIA8() {}
+
+  // Routine for doing the job of reading and setting initialization info.  
+  bool setInit(); 
+
+  // Routine for doing the job of reading and setting info on next event.  
+  bool setEvent(int = 0); 
+
+  // Update cross-section information at the end of the run.
+  bool updateSigma();
+
+private:
+
+  // Pointers to process event record and further information.
+  Event* processPtr;
+  Info*  infoPtr;
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_LesHouches_H
diff --git a/PYTHIA8/pythia8140/include/MiniStringFragmentation.h b/PYTHIA8/pythia8140/include/MiniStringFragmentation.h
new file mode 100644 (file)
index 0000000..92db747
--- /dev/null
@@ -0,0 +1,86 @@
+// MiniStringFragmentation.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the class for "cluster" fragmentation.
+// MiniStringFragmentation: handle the fragmentation of low-mass systems.
+
+#ifndef Pythia8_MiniStringFragmentation_H
+#define Pythia8_MiniStringFragmentation_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "FragmentationSystems.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// The MiniStringFragmentation class contains the routines to fragment 
+// occasional low-mass colour singlet partonic systems, where the string 
+// approach is not directly applicable (for technical reasons).
+
+class MiniStringFragmentation {
+
+public:
+
+  // Constructor. 
+  MiniStringFragmentation() {}
+
+  // Initialize and save pointers.
+  void init(Info* infoPtrIn, Settings& settings,  
+    ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, 
+    StringFlav* flavSelPtrIn);
+
+  // Do the fragmentation: driver routine.
+  bool fragment( int iSub, ColConfig& colConfig, Event& event, 
+    bool isDiff = false);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NTRYDIFFRACTIVE, NTRYLASTRESORT, NTRYFLAV;
+  static const double SIGMAMIN;
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*         rndmPtr;
+
+  // Pointer to class for flavour generation.
+  StringFlav*   flavSelPtr;
+
+  // Initialization data, read from Settings.
+  int    nTryMass;
+  double sigma, sigma2Had, bLund;
+
+  // Data members.
+  bool   isClosed;
+  double mSum, m2Sum;
+  Vec4   pSum;
+  vector<int> iParton;
+  FlavContainer flav1, flav2;
+
+  // Attempt to produce two particles from a cluster.
+  bool ministring2two( int nTry, Event& event);
+
+  // Attempt to produce one particle from a cluster.
+  bool ministring2one( int iSub, ColConfig& colConfig, Event& event);
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_MiniStringFragmentation_H
diff --git a/PYTHIA8/pythia8140/include/MultipleInteractions.h b/PYTHIA8/pythia8140/include/MultipleInteractions.h
new file mode 100644 (file)
index 0000000..5f3a062
--- /dev/null
@@ -0,0 +1,259 @@
+// MultipleInteractions.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main classes for multiple interactions physics.
+// SigmaMultiple stores allowed processes by in-flavour combination.
+// MultipleInteractions: generates multiple parton-parton interactions.
+
+#ifndef Pythia8_MultipleInteractions_H
+#define Pythia8_MultipleInteractions_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Event.h"
+#include "Info.h"
+#include "PartonSystems.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SigmaProcess.h"
+#include "StandardModel.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// SigmaMultiple is a helper class to MultipleInteractions.
+// It packs pointers to the allowed processes for different 
+// flavour combinations and levels of ambition.
+
+class SigmaMultiple {
+
+public:
+
+  // Constructor.
+  SigmaMultiple() {}
+  
+  // Destructor.
+  ~SigmaMultiple() {
+    for (int i = 0; i < int(sigmaT.size()); ++i) delete sigmaT[i];
+    for (int i = 0; i < int(sigmaU.size()); ++i) delete sigmaU[i];}   
+
+  // Initialize list of processes.
+  bool init(int inState, int processLevel, Info* infoPtr, 
+    Settings* settingsPtr, ParticleData* particleDataPtr, Rndm* rndmPtrIn, 
+    BeamParticle* beamAPtr, BeamParticle* beamBPtr, CoupSM* coupSMPtr);
+
+  // Calculate cross section summed over possibilities.
+  double sigma( int id1, int id2, double x1, double x2, double sHat, 
+    double tHat, double uHat, double alpS, double alpEM,
+    bool restore = false, bool pickOtherIn = false);
+
+  // Return whether the other, rare processes were selected.
+  bool pickedOther() {return pickOther;} 
+
+  // Return one subprocess, picked according to relative cross sections.
+  SigmaProcess* sigmaSel();
+  bool swapTU() {return pickedU;}
+
+  // Return code or name of a specified process, for statistics table.
+  int    nProc() const {return nChan;}
+  int    codeProc(int iProc) const {return sigmaT[iProc]->code();}
+  string nameProc(int iProc) const {return sigmaT[iProc]->name();}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double MASSMARGIN, OTHERFRAC;
+
+  // Number of processes. Some use massive matrix elements.
+  int            nChan;
+  vector<bool>   needMasses;
+  vector<double> m3Fix, m4Fix, sHatMin;
+
+  // Vector of process list, one for t-channel and one for u-channel.
+  vector<SigmaProcess*> sigmaT, sigmaU;
+
+  // Values of cross sections in process list above.
+  vector<double> sigmaTval, sigmaUval;
+  double         sigmaTsum, sigmaUsum;
+  bool           pickOther, pickedU;
+
+  // Pointer to the random number generator.
+  Rndm*          rndmPtr;
+  
+};
+//==========================================================================
+
+// The MultipleInteractions class contains the main methods for the 
+// generation of multiple parton-parton interactions in hadronic collisions.
+
+class MultipleInteractions {
+
+public:
+
+  // Constructor.
+  MultipleInteractions() {}
+
+  // Initialize the generation process for given beams.
+  bool init( bool doMIinit, int diffractiveModeIn, Info* infoPtrIn, 
+    Settings& settings, ParticleData* particleDataPtr, Rndm* rndmPtrIn, 
+    BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, CoupSM* coupSMPtrIn, 
+    PartonSystems* partonSystemsPtrIn, SigmaTotal* sigmaTotPtrIn, 
+    ostream& os = cout);
+
+  // Reset impact parameter choice and update the CM energy.
+  void reset();
+
+  // Select first = hardest pT in minbias process.
+  void pTfirst(); 
+
+  // Set up kinematics for first = hardest pT in minbias process.
+  void setupFirstSys( Event& process);
+
+  // Find whether to limit maximum scale of emissions.
+  bool limitPTmax( Event& event);
+
+  // Prepare system for evolution.
+  void prepare(double pTscale = 1000.) {
+    if (!bSetInFirst) overlapNext(pTscale);}
+
+  // Select next pT in downwards evolution.
+  double pTnext( double pTbegAll, double pTendAll, Event& event);
+
+  // Set up kinematics of acceptable interaction.
+  void scatter( Event& event); 
+
+  // Get some information on current interaction.
+  double Q2Ren()     const {return pT2Ren;}
+  double alphaSH()   const {return alpS;}
+  double alphaEMH()  const {return alpEM;}
+  double x1H()       const {return x1;} 
+  double x2H()       const {return x2;} 
+  double Q2Fac()     const {return pT2Fac;}
+  double pdf1()      const {return xPDF1now;}
+  double pdf2()      const {return xPDF2now;}
+  double bMI()       const {return (bIsSet) ? bNow / bAvg : 0.;}
+  double enhanceMI() const {return (bIsSet) ? enhanceB / zeroIntCorr : 1.;}
+
+  // Update and print statistics on number of processes.
+  void accumulate() { int iBeg = (infoPtr->isMinBias()) ? 0 : 1; 
+    for (int i = iBeg; i < infoPtr->nMI(); ++i) ++nGen[ infoPtr->codeMI(i) ];}
+  void statistics(bool resetStat = false, ostream& os = cout);
+  
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const bool   SHIFTFACSCALE, PREPICKRESCATTER;
+  static const double SIGMAFUDGE, RPT20, PT0STEP, SIGMASTEP, PT0MIN,
+                      EXPPOWMIN, PROBATLOWB, BSTEP, BMAX, EXPMAX, 
+                      KCONVERGE, CONVERT2MB, ROOTMIN, ECMDEV;
+
+  // Initialization data, read from Settings.
+  bool   allowRescatter, allowDoubleRes;
+  int    pTmaxMatch, alphaSorder, alphaEMorder, bProfile, processLevel, 
+         rescatterMode, nQuarkIn, nSample, enhanceScreening;
+  double alphaSvalue, Kfactor, pT0Ref, ecmRef, ecmPow, pTmin, coreRadius, 
+         coreFraction, expPow, ySepResc, deltaYResc, sigmaPomP, 
+         mMaxPertDiff, mMinPertDiff;
+
+  // Other initialization data.
+  bool   hasBaryonBeams, hasLowPow;
+  int    diffractiveMode;
+  double eCM, sCM, pT0, pT20, pT2min, pTmax, pT2max, pT20R, pT20minR, 
+         pT20maxR, pT20min0maxR, pT2maxmin, sigmaND, pT4dSigmaMax, 
+         pT4dProbMax, dSigmaApprox, sigmaInt, sudExpPT[101], 
+         zeroIntCorr, normOverlap, nAvg, kNow, normPi, bAvg, bDiv, 
+         probLowB, radius2B, radius2C, fracA, fracB, fracC, fracAhigh, 
+         fracBhigh, fracChigh, fracABChigh, expRev, cDiv, cMax;
+
+  // Properties specific to current system.
+  bool   bIsSet, bSetInFirst, isAtLowB, pickOtherSel;
+  int    id1, id2, i1Sel, i2Sel, id1Sel, id2Sel;
+  double bNow, enhanceB, pT2, pT2shift, pT2Ren, pT2Fac, x1, x2, xT, xT2, 
+         tau, y, sHat, tHat, uHat, alpS, alpEM, xPDF1now, xPDF2now,
+         dSigmaSum, x1Sel, x2Sel, sHatSel, tHatSel, uHatSel;
+
+  // Stored values for mass interpolation for diffractive systems.
+  int    nStep, iStepFrom, iStepTo; 
+  double eCMsave, eStepSize, eStepSave, eStepFrom, eStepTo, pT0Save[5], 
+         pT4dSigmaMaxSave[5], pT4dProbMaxSave[5], sigmaIntSave[5], 
+         sudExpPTSave[5][101], zeroIntCorrSave[5], normOverlapSave[5], 
+         kNowSave[5], bAvgSave[5], bDivSave[5], probLowBSave[5], 
+         fracAhighSave[5], fracBhighSave[5], fracChighSave[5], 
+         fracABChighSave[5], cDivSave[5], cMaxSave[5];
+
+  // Pointer to various information on the generation.
+  Info*          infoPtr;
+
+  // Pointer to the random number generator.
+  Rndm*          rndmPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle*  beamAPtr;
+  BeamParticle*  beamBPtr;
+
+  // Pointers to Standard Model couplings.
+  CoupSM*        coupSMPtr;
+
+  // Pointer to information on subcollision parton locations.
+  PartonSystems* partonSystemsPtr;
+
+  // Pointer to total cross section parametrization.
+  SigmaTotal*    sigmaTotPtr;
+
+  // Collections of parton-level 2 -> 2 cross sections. Selected one.
+  SigmaMultiple  sigma2gg, sigma2qg, sigma2qqbarSame, sigma2qq;
+  SigmaMultiple* sigma2Sel;
+  SigmaProcess*  dSigmaDtSel;
+
+  // Statistics on generated 2 -> 2 processes.
+  map<int, int>  nGen;
+
+  // alphaStrong and alphaEM calculations.
+  AlphaStrong    alphaS;
+  AlphaEM        alphaEM;
+
+  // Scattered partons.
+  vector<int>    scatteredA, scatteredB;
+
+  // Determine constant in d(Prob)/d(pT2) < const / (pT2 + r * pT20)^2.  
+  void upperEnvelope();
+
+  // Integrate the parton-parton interaction cross section.
+  void jetCrossSection();
+
+  // Evaluate "Sudakov form factor" for not having a harder interaction.
+  double sudakov(double pT2sud, double enhance = 1.);
+
+  // Do a quick evolution towards the next smaller pT.
+  double fastPT2( double pT2beg);
+
+  // Calculate the actual cross section, either for the first interaction
+  // (including at initialization) or for any subsequent in the sequence. 
+  double sigmaPT2scatter(bool isFirst = false);
+
+  // Find the partons that may rescatter.
+  void findScatteredPartons( Event& event); 
+
+  // Calculate the actual cross section for a rescattering. 
+  double sigmaPT2rescatter( Event& event);
+
+  // Calculate factor relating matter overlap and interaction rate.
+  void overlapInit();
+
+  // Pick impact parameter and interaction rate enhancement,
+  // either before the first interaction (for minbias) or after it.
+  void overlapFirst();
+  void overlapNext(double pTscale);
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_MultipleInteractions_H
diff --git a/PYTHIA8/pythia8140/include/ParticleData.h b/PYTHIA8/pythia8140/include/ParticleData.h
new file mode 100644 (file)
index 0000000..25ed888
--- /dev/null
@@ -0,0 +1,594 @@
+// ParticleData.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for the classes containing particle data.
+// DecayChannel contains info on a single decay channel.
+// ParticleDataEntry contains info on a single particle species.
+// ParticleData collects info on all particles as a map.
+
+#ifndef Pythia8_ParticleData_H
+#define Pythia8_ParticleData_H
+
+#include "Basics.h"
+#include "Info.h"
+#include "PythiaStdlib.h"
+#include "ResonanceWidths.h"
+#include "Settings.h"
+#include "StandardModel.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Forward reference to some classes.
+class ParticleData;
+class ResonanceWidths;
+class CoupSM;
+  
+//==========================================================================
+
+// This class holds info on a single decay channel.
+
+class DecayChannel {
+
+public:
+  // Constructor.
+  DecayChannel(int onModeIn = 0, double bRatioIn = 0., int meModeIn = 0, 
+    int prod0 = 0, int prod1 = 0, int prod2 = 0, int prod3 = 0, 
+    int prod4 = 0, int prod5 = 0, int prod6 = 0, int prod7 = 0) 
+    : onModeSave(onModeIn), bRatioSave(bRatioIn), currentBRSave(0.), 
+    onShellWidthSave(0.), openSecPos(1.), openSecNeg(1.),
+    meModeSave(meModeIn), nProd(0), hasChangedSave(true) {
+    prod[0] = prod0; prod[1] = prod1; prod[2] = prod2; prod[3] = prod3; 
+    prod[4] = prod4; prod[5] = prod5; prod[6] = prod6; prod[7] = prod7; 
+    for (int j = 0; j < 8; ++j) if (prod[j] != 0 && j == nProd) ++nProd; }  
+
+  // Member functions for input.
+  void onMode(int onModeIn) {onModeSave = onModeIn; hasChangedSave = true;}
+  void bRatio(double bRatioIn, bool countAsChanged = true) {
+    bRatioSave = bRatioIn; if (countAsChanged) hasChangedSave = true;}
+  void rescaleBR(double fac) {bRatioSave *= fac; hasChangedSave = true;} 
+  void meMode(int meModeIn) {meModeSave = meModeIn; hasChangedSave = true;} 
+  void multiplicity(int multIn)  {nProd = multIn; hasChangedSave = true;} 
+  void product(int i, int prodIn) {prod[i] = prodIn; nProd = 0;
+    for (int j = 0; j < 8; ++j) if (prod[j] != 0 && j == nProd) ++nProd;   
+    hasChangedSave = true;}
+  void setHasChanged(bool hasChangedIn) {hasChangedSave = hasChangedIn;}
+
+  // Member functions for output.
+  int    onMode()       const {return onModeSave;}
+  double bRatio()       const {return bRatioSave;}
+  int    meMode()       const {return meModeSave;}
+  int    multiplicity() const {return nProd;} 
+  int    product(int i) const {return (i >= 0 && i < nProd) ? prod[i] : 0;} 
+  bool   hasChanged()   const { return hasChangedSave;}
+
+  // Check for presence of particles anywhere in decay list.
+  bool   contains(int id1) const;
+  bool   contains(int id1, int id2) const;
+  bool   contains(int id1, int id2, int id3) const;
+
+  // Input/output for current selection of decay modes.
+  // Takes into account on/off switches and dynamic width for resonances.
+  void   currentBR(double currentBRIn) {currentBRSave = currentBRIn;}
+  double currentBR() const {return currentBRSave;}
+
+  // Input/output for nominal partial width; used by resonances. 
+  void   onShellWidth(double onShellWidthIn) {
+         onShellWidthSave = onShellWidthIn;} 
+  double onShellWidth() const {return onShellWidthSave;} 
+  void   onShellWidthFactor(double factor) {onShellWidthSave *= factor;} 
+
+  // Input/output for fraction of secondary open widths; used by resonances. 
+  void   openSec(int idSgn, double openSecIn) {
+    if (idSgn > 0) openSecPos = openSecIn; else openSecNeg = openSecIn;} 
+  double openSec(int idSgn) const {
+    return (idSgn > 0) ? openSecPos : openSecNeg;} 
+
+private:
+
+  // Decay channel info.
+  int    onModeSave;
+  double bRatioSave, currentBRSave, onShellWidthSave, openSecPos, 
+         openSecNeg;
+  int    meModeSave, nProd, prod[8];
+  bool   hasChangedSave;
+
+};
+
+//==========================================================================
+
+// This class holds info on a single particle species.
+
+class ParticleDataEntry {
+
+public:
+
+  // Constructors: for antiparticle exists or not.
+  ParticleDataEntry(int idIn = 0, string nameIn = " ", 
+    int spinTypeIn = 0, int chargeTypeIn = 0, int colTypeIn = 0, 
+    double m0In = 0., double mWidthIn = 0., double mMinIn = 0., 
+    double mMaxIn = 0., double tau0In = 0.) : idSave(abs(idIn)), 
+    nameSave(nameIn), antiNameSave("void"),  spinTypeSave(spinTypeIn), 
+    chargeTypeSave(chargeTypeIn), colTypeSave(colTypeIn), m0Save(m0In), 
+    mWidthSave (mWidthIn), mMinSave(mMinIn), mMaxSave(mMaxIn), 
+    tau0Save(tau0In), hasAntiSave(false), hasChangedSave(true), 
+    resonancePtr(0) {setDefaults();} 
+  ParticleDataEntry(int idIn, string nameIn, string antiNameIn, 
+    int spinTypeIn = 0, int chargeTypeIn = 0, int colTypeIn = 0, 
+    double m0In = 0., double mWidthIn = 0., double mMinIn = 0., 
+    double mMaxIn = 0., double tau0In = 0.) : idSave(abs(idIn)), 
+    nameSave(nameIn), antiNameSave(antiNameIn), spinTypeSave(spinTypeIn), 
+    chargeTypeSave(chargeTypeIn), colTypeSave(colTypeIn), m0Save(m0In), 
+    mWidthSave (mWidthIn), mMinSave(mMinIn), mMaxSave(mMaxIn), 
+    tau0Save(tau0In), hasAntiSave(true), hasChangedSave(true),
+    resonancePtr(0) {setDefaults(); 
+    if (toLower(antiNameIn) == "void") hasAntiSave = false;} 
+
+  // Destructor: delete any ResonanceWidths object.
+  ~ParticleDataEntry();
+
+  // Initialization of some particle flags.
+  void setDefaults();
+
+  // Store pointer to whole particle data table/database.
+  void initPtr( ParticleData* particleDataPtrIn) {
+    particleDataPtr = particleDataPtrIn;}
+
+  // Reset all the properties of an existing particle.
+  void setAll(string nameIn, string antiNameIn, int spinTypeIn = 0,
+    int chargeTypeIn = 0, int colTypeIn = 0, double m0In = 0., 
+    double mWidthIn = 0., double mMinIn = 0., double mMaxIn = 0., 
+    double tau0In = 0.) 
+    {nameSave = nameIn; antiNameSave = antiNameIn; hasAntiSave = true; 
+    if (toLower(antiNameIn) == "void") hasAntiSave = false;
+    spinTypeSave = spinTypeIn; chargeTypeSave = chargeTypeIn; 
+    colTypeSave = colTypeIn; m0Save = m0In; mWidthSave = mWidthIn;
+    mMinSave = mMinIn; mMaxSave = mMaxIn; tau0Save = tau0In; 
+    setDefaults(); hasChangedSave = true;}
+
+  // Change current values one at a time (or set if not set before).
+  // (Must use set here since else name+signature clash with get methods.)
+  void setName(string nameIn) {nameSave = nameIn; hasChangedSave = true;}
+  void setAntiName(string antiNameIn) {antiNameSave = antiNameIn; 
+    hasChangedSave = true;}
+  void setNames(string nameIn, string antiNameIn) {nameSave = nameIn; 
+    antiNameSave = antiNameIn; hasAntiSave = true; if (toLower(antiNameIn) 
+    == "void") hasAntiSave = false; hasChangedSave = true;}
+  void setSpinType(int spinTypeIn) {spinTypeSave = spinTypeIn; 
+    hasChangedSave = true;}
+  void setChargeType(int chargeTypeIn) {chargeTypeSave = chargeTypeIn; 
+    hasChangedSave = true;}
+  void setColType(int colTypeIn) {colTypeSave = colTypeIn; 
+    hasChangedSave = true;}
+  void setM0(double m0In) {m0Save = m0In; setConstituentMass(); 
+    hasChangedSave = true;}
+  void setMWidth(double mWidthIn, bool countAsChanged = true) {
+    mWidthSave = mWidthIn; if (countAsChanged) hasChangedSave = true;}
+  void setMMin(double mMinIn) {mMinSave = mMinIn; hasChangedSave = true;}
+  void setMMax(double mMaxIn) {mMaxSave = mMaxIn; hasChangedSave = true;}
+  void setTau0(double tau0In) {tau0Save = tau0In; hasChangedSave = true;}
+  void setIsResonance(bool isResonanceIn) {isResonanceSave = isResonanceIn; 
+    hasChangedSave = true;}
+  void setMayDecay(bool mayDecayIn, bool countAsChanged = true) {
+    mayDecaySave = mayDecayIn; if (countAsChanged) hasChangedSave = true;}
+  void setDoExternalDecay(bool doExternalDecayIn) 
+    {doExternalDecaySave = doExternalDecayIn; hasChangedSave = true;}
+  void setIsVisible(bool isVisibleIn) {isVisibleSave = isVisibleIn; 
+    hasChangedSave = true;}
+  void setDoForceWidth(bool doForceWidthIn) {doForceWidthSave = doForceWidthIn; 
+    hasChangedSave = true;}
+  void setHasChanged(bool hasChangedIn) {hasChangedSave = hasChangedIn;
+    for (int i = 0; i < int(channels.size()); ++i) 
+      channels[i].setHasChanged(hasChangedIn);}
+
+  // Give back current values. 
+  int    id()                     const { return idSave; }
+  bool   hasAnti()                const { return hasAntiSave; } 
+  string name(int idIn = 1)       const { 
+         return (idIn > 0) ? nameSave : antiNameSave; } 
+  int    spinType() const {return spinTypeSave; }
+  int    chargeType(int idIn = 1) const { 
+         return (idIn > 0) ? chargeTypeSave : -chargeTypeSave; } 
+  double charge(int idIn = 1)     const { 
+         return (idIn > 0) ? chargeTypeSave / 3. : -chargeTypeSave / 3.; } 
+  int    colType(int idIn = 1)    const { 
+         if (colTypeSave == 2) return colTypeSave;
+         return (idIn > 0) ? colTypeSave : -colTypeSave; } 
+  double m0()                     const { return m0Save; } 
+  double mWidth()                 const { return mWidthSave; } 
+  double mMin()                   const { return mMinSave; } 
+  double mMax()                   const { return mMaxSave; } 
+  double m0Min()                  const { 
+         return (modeBWnow == 0) ? m0Save : mMinSave; } 
+  double m0Max()                  const { 
+         return (modeBWnow == 0) ? m0Save : mMaxSave; } 
+  double tau0()                   const { return tau0Save; } 
+  bool   isResonance()            const { return isResonanceSave; } 
+  bool   mayDecay()               const { return mayDecaySave; } 
+  bool   doExternalDecay()        const { return doExternalDecaySave; } 
+  bool   isVisible()              const { return isVisibleSave; }
+  bool   doForceWidth()           const { return doForceWidthSave; }
+  bool   hasChanged()     const { if (hasChangedSave) return true;
+         for (int i = 0; i < int(channels.size()); ++i) 
+         if (channels[i].hasChanged()) return true; return false;}
+
+  // Set and give back several mass-related quantities.
+  void   initBWmass(); 
+  double constituentMass()        const { return constituentMassSave; } 
+  double mass(); 
+  double mRun(double mH);
+
+  // Give back other quantities.
+  bool   useBreitWigner() const { return (modeBWnow > 0); }
+  bool   canDecay()       const { return (channels.size() > 0);} 
+  bool   isLepton()       const { return (idSave > 10 && idSave < 19);}
+  bool   isQuark()        const { return (idSave != 0 && idSave < 9);}
+  bool   isGluon()        const { return (idSave == 21);}
+  bool   isDiquark()      const { return (idSave > 1000 && idSave < 10000 
+         && (idSave/10)%10 == 0);}
+  bool   isHadron()       const; 
+  bool   isMeson()        const; 
+  bool   isBaryon()       const;
+
+  // Intermediate octet ccbar or bbar states in colour-octet model. 
+  bool   isOctetHadron()  const {return (idSave == 9900441
+         || idSave == 9900443 || idSave == 9900551 || idSave == 9900553 
+         || idSave == 9910441 || idSave == 9910551); }
+  int    heaviestQuark(int idIn = 1)    const; 
+  int    baryonNumberType(int idIn = 1) const;
+
+  // Reset to empty decay table.
+  void clearChannels() {channels.resize(0);}
+
+  // Add a decay channel to the decay table.
+  void addChannel(int onMode = 0, double bRatio = 0., int meMode = 0, 
+    int prod0 = 0, int prod1 = 0, int prod2 = 0, int prod3 = 0, 
+    int prod4 = 0, int prod5 = 0, int prod6 = 0, int prod7 = 0) { 
+    channels.push_back( DecayChannel( onMode, bRatio, meMode, prod0, 
+    prod1, prod2, prod3, prod4, prod5, prod6, prod7) ); }
+
+  // Decay table size.
+  int sizeChannels() const {return channels.size();}
+
+  // Gain access to a channel in the decay table.
+  DecayChannel& channel(int i){return channels[i];}
+  const DecayChannel& channel(int i) const {return channels[i];}
+
+  // Rescale sum of branching ratios to unity.
+  void rescaleBR(double newSumBR = 1.);
+
+  // Random choice of decay channel according to branching ratios.
+  bool preparePick(int idSgn, double mHat = 0., int idInFlav = 0);
+  DecayChannel& pickChannel();
+
+  // Access methods stored in ResonanceWidths.
+  void   setResonancePtr(ResonanceWidths* resonancePtrIn); 
+  ResonanceWidths* getResonancePtr() {return resonancePtr;}
+  void   resInit(Info* infoPtrIn, Settings* settingsPtrIn, 
+    ParticleData* particleDataPtrIn, CoupSM* coupSMPtrIn);
+  double resWidth(int idSgn, double mHat, int idIn = 0, 
+    bool openOnly = false, bool setBR = false);
+  double resWidthOpen(int idSgn, double mHat, int idIn = 0);
+  double resWidthStore(int idSgn, double mHat, int idIn = 0);
+  double resOpenFrac(int idSgn);
+  double resWidthRescaleFactor();
+  double resWidthChan(double mHat, int idAbs1 = 0, int idAbs2 = 0);
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    INVISIBLENUMBER, INVISIBLETABLE[38];
+  static const double MAXTAU0FORDECAY,MINMASSRESONANCE, NARROWMASS,
+                      CONSTITUENTMASSTABLE[6];
+
+  // Particle data.
+  int    idSave;
+  string nameSave, antiNameSave;
+  int    spinTypeSave, chargeTypeSave, colTypeSave;
+  double m0Save, mWidthSave, mMinSave, mMaxSave, tau0Save, 
+         constituentMassSave;
+  bool   hasAntiSave, isResonanceSave, mayDecaySave, doExternalDecaySave, 
+         isVisibleSave, doForceWidthSave, hasChangedSave;
+
+  // Extra data for mass selection according to a Breit-Wigner.
+  int    modeBWnow;
+  double atanLow, atanDif, mThr;   
+
+  // A vector containing all the decay channels of the particle.
+  vector<DecayChannel> channels;
+
+  // Summed branching ratio of currently open channels.
+  double currentBRSum;
+
+  // Pointer to ResonanceWidths object; only used for some particles.
+  ResonanceWidths* resonancePtr;  
+
+  // Pointer to the full particle data table.
+  ParticleData* particleDataPtr;
+
+  // Set constituent mass. 
+  void setConstituentMass();
+
+  // Useful functions for string handling.
+  string toLower(const string& nameConv);
+
+};
+
+//==========================================================================
+
+// This class holds a map of all ParticleDataEntries.
+
+class ParticleData {
+
+public:
+
+  // Constructor.
+  ParticleData() : isInit(false) {}
+
+  // Initialize pointers.
+  void initPtr(Info* infoPtrIn, Settings* settingsPtrIn, Rndm* rndmPtrIn, 
+    CoupSM* coupSMPtrIn) {infoPtr = infoPtrIn; settingsPtr = settingsPtrIn;
+    rndmPtr = rndmPtrIn; coupSMPtr = coupSMPtrIn;}
+  // Read in database from specific file.
+  bool init(string startFile = "../xmldoc/ParticleData.xml") {
+    initCommon(); return readXML(startFile);}
+
+  // Overwrite existing database by reading from specific file.
+  bool reInit(string startFile, bool xmlFormat = true) { initCommon();
+    return (xmlFormat) ? readXML(startFile) : readFF(startFile);}
+
+  // Initialize pointers, normal Breit-Wigners and special resonances.
+  void initWidths(vector<ResonanceWidths*> resonancePtrs);
+
+  // Read or list whole (or part of) database from/to an XML file.
+  bool readXML(string inFile, bool reset = true) ; 
+  void listXML(string outFile); 
+
+  // Read or list whole (or part of) database from/to a free format file.
+  bool readFF(string inFile, bool reset = true) ; 
+  void listFF(string outFile); 
+
+  // Read in one update from a single line.
+  bool readString(string lineIn, bool warn = true, ostream& os = cout) ; 
+
+  // Print out table of whole database, or of only part of it.
+  void listAll(ostream& os = cout) {list(false, true, os);} 
+  void listChanged(ostream& os = cout) {list(true, false, os);} 
+  void listChanged(bool changedRes, ostream& os = cout) {
+    list(true, changedRes, os);} 
+  void list(bool changedOnly = false, bool changedRes = true, 
+    ostream& os = cout); 
+
+  // Print out specified particles.
+  void list(int idList, ostream& os = cout) {vector<int> idListTemp; 
+    idListTemp.push_back(idList); list( idListTemp, os);} 
+  void list(vector<int> idList, ostream& os = cout); 
+
+  // Check that table makes sense, especially for decays.
+  void checkTable(ostream& os = cout) {checkTable(1, os);};
+  void checkTable(int verbosity, ostream& os = cout) ;
+  // Add new entry.
+  void addParticle(int idIn, string nameIn = " ", int spinTypeIn = 0, 
+    int chargeTypeIn = 0, int colTypeIn = 0, double m0In = 0., 
+    double mWidthIn = 0., double mMinIn = 0., double mMaxIn = 0., 
+    double tau0In = 0.) { pdt[abs(idIn)] = ParticleDataEntry(idIn, 
+    nameIn, spinTypeIn, chargeTypeIn, colTypeIn, m0In, mWidthIn, 
+    mMinIn, mMaxIn, tau0In); }  
+  void addParticle(int idIn, string nameIn, string antiNameIn, 
+    int spinTypeIn = 0, int chargeTypeIn = 0, int colTypeIn = 0, 
+    double m0In = 0., double mWidthIn = 0., double mMinIn = 0., 
+    double mMaxIn = 0., double tau0In = 0.) { pdt[abs(idIn)] 
+    = ParticleDataEntry(idIn, nameIn, antiNameIn, spinTypeIn, 
+    chargeTypeIn, colTypeIn, m0In, mWidthIn, mMinIn, mMaxIn, tau0In); }  
+
+  // Reset all the properties of an entry in one go..
+  void setAll(int idIn, string nameIn, string antiNameIn, 
+    int spinTypeIn = 0, int chargeTypeIn = 0, int colTypeIn = 0, 
+    double m0In = 0., double mWidthIn = 0., double mMinIn = 0., 
+    double mMaxIn = 0.,double tau0In = 0.) { if (isParticle(idIn)) 
+    pdt[abs(idIn)].setAll( nameIn, antiNameIn, spinTypeIn, chargeTypeIn, 
+    colTypeIn, m0In, mWidthIn, mMinIn, mMaxIn, tau0In); }  
+
+  // Query existence of an entry.
+  bool isParticle(int idIn) {
+    if (pdt.find(abs(idIn)) == pdt.end()) return false;
+    if (idIn > 0 || pdt[abs(idIn)].hasAnti()) return true;
+    return false; }
+
+  // Return the id of the sequentially next particle stored in table.
+  int nextId(int idIn) ;
+
+  // Change current values one at a time (or set if not set before).
+  void name(int idIn, string nameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setName(nameIn); }
+  void antiName(int idIn, string antiNameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setAntiName(antiNameIn); }
+  void names(int idIn, string nameIn, string antiNameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setNames(nameIn, antiNameIn); }
+  void spinType(int idIn, int spinTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setSpinType(spinTypeIn); }
+  void chargeType(int idIn, int chargeTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setChargeType(chargeTypeIn); }
+  void colType(int idIn, int colTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setColType(colTypeIn); }
+  void m0(int idIn, double m0In) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setM0(m0In); }
+  void mWidth(int idIn, double mWidthIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMWidth(mWidthIn); }
+  void mMin(int idIn, double mMinIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMMin(mMinIn); }
+  void mMax(int idIn, double mMaxIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMMax(mMaxIn); }
+  void tau0(int idIn, double tau0In) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setTau0(tau0In); }
+  void isResonance(int idIn, bool isResonanceIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setIsResonance(isResonanceIn); }
+  void mayDecay(int idIn, bool mayDecayIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMayDecay(mayDecayIn); }
+  void doExternalDecay(int idIn, bool doExternalDecayIn) {
+    if (isParticle(idIn)) 
+    pdt[abs(idIn)].setDoExternalDecay(doExternalDecayIn); }
+  void isVisible(int idIn, bool isVisibleIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setIsVisible(isVisibleIn); }
+  void doForceWidth(int idIn, bool doForceWidthIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setDoForceWidth(doForceWidthIn); }
+  void hasChanged(int idIn, bool hasChangedIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setHasChanged(hasChangedIn); }
+  // Give back current values. 
+  bool hasAnti(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].hasAnti() : false ; } 
+  string name(int idIn) {
+    return (isParticle(abs(idIn))) ? pdt[abs(idIn)].name(idIn) : " "; }
+  int spinType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].spinType() : 0 ; } 
+  int chargeType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].chargeType(idIn) : 0 ; } 
+  double charge(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].charge(idIn) : 0 ; } 
+  int colType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].colType(idIn) : 0 ; } 
+  double m0(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0() : 0. ; } 
+  double mWidth(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mWidth() : 0. ; } 
+  double mMin(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mMin() : 0. ; } 
+  double m0Min(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0Min() : 0. ; } 
+  double mMax(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mMax() : 0. ; } 
+  double m0Max(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0Max() : 0. ; } 
+  double tau0(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].tau0() : 0. ; } 
+  bool isResonance(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isResonance() : false ; } 
+  bool mayDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mayDecay() : false ; } 
+  bool doExternalDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].doExternalDecay() : false ; }
+  bool isVisible(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isVisible() : false ; } 
+  bool doForceWidth(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].doForceWidth() : false ; } 
+  bool hasChanged(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].hasChanged() : false ; } 
+
+  // Give back special mass-related quantities.
+  bool useBreitWigner(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].useBreitWigner() : false ; } 
+  double constituentMass(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].constituentMass() : 0. ; } 
+  double mass(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mass() : 0. ; } 
+  double mRun(int idIn, double mH) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mRun(mH) : 0. ; } 
+
+  // Give back other quantities.
+  bool canDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].canDecay() : false ; }
+  bool isLepton(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isLepton() : false ; } 
+  bool isQuark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isQuark() : false ; } 
+  bool isGluon(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isGluon() : false ; } 
+  bool isDiquark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isDiquark() : false ; } 
+  bool isHadron(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isHadron() : false ; } 
+  bool isMeson(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isMeson() : false ; } 
+  bool isBaryon(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isBaryon() : false ; } 
+  bool isOctetHadron(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isOctetHadron() : false ; } 
+  int heaviestQuark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].heaviestQuark(idIn) : 0 ; }  
+  int baryonNumberType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].baryonNumberType(idIn) : 0 ; }  
+
+  // Change branching ratios.
+  void rescaleBR(int idIn, double newSumBR = 1.) {
+    if (isParticle(idIn)) pdt[abs(idIn)].rescaleBR(newSumBR); }
+
+  // Access methods stored in ResonanceWidths.
+  void setResonancePtr(int idIn, ResonanceWidths* resonancePtrIn) { 
+    if (isParticle(idIn)) pdt[abs(idIn)].setResonancePtr( resonancePtrIn);} 
+  void resInit(int idIn) { if (isParticle(idIn)) 
+    pdt[abs(idIn)].resInit(infoPtr, settingsPtr, this, coupSMPtr);} 
+  double resWidth(int idIn, double mHat, int idInFlav = 0, 
+    bool openOnly = false, bool setBR = false) {
+    return isParticle(idIn) ? pdt[abs(idIn)].resWidth(idIn, mHat,
+    idInFlav, openOnly, setBR) : 0.;}
+  double resWidthOpen(int idIn, double mHat, int idInFlav = 0) {
+    return isParticle(idIn) ? pdt[abs(idIn)].resWidthOpen(idIn, mHat, 
+    idInFlav) : 0.;}
+  double resWidthStore(int idIn, double mHat, int idInFlav = 0) {
+    return isParticle(idIn) ? pdt[abs(idIn)].resWidthStore(idIn, mHat, 
+    idInFlav) : 0.;}
+  double resOpenFrac(int id1In, int id2In = 0, int id3In = 0);
+  double resWidthRescaleFactor(int idIn) { return isParticle(idIn) 
+    ? pdt[abs(idIn)].resWidthRescaleFactor() : 0.;}
+  double resWidthChan(int idIn, double mHat, int idAbs1 = 0, 
+    int idAbs2 = 0) { return isParticle(idIn) 
+    ? pdt[abs(idIn)].resWidthChan( mHat, idAbs1, idAbs2) : 0.;}
+  
+  // Return pointer to entry.
+  ParticleDataEntry* particleDataEntryPtr(int idIn) {
+    return (isParticle(idIn)) ? &pdt[abs(idIn)] : &pdt[0]; }
+
+private:
+
+  // Common data, accessible for the individual particles.
+  int    modeBreitWigner;
+  double maxEnhanceBW, mQRun[7], Lambda5Run;
+
+  // The individual particle need access to the full database.
+  friend class ParticleDataEntry;
+
+  // Pointer to various information on the generation.
+  Info*     infoPtr;
+
+  // Pointer to the settings database.
+  Settings* settingsPtr;
+
+  // Pointer to the random number generator.
+  Rndm*     rndmPtr;
+
+  // Pointer to Standard Model couplings.
+  CoupSM*   coupSMPtr;
+
+  // All particle data stored in a map.
+  map<int, ParticleDataEntry> pdt;
+
+  // Pointer to current particle (e.g. when reading decay channels).
+  ParticleDataEntry* particlePtr;
+
+  // Flag that initialization has been performed.
+  bool   isInit;
+
+  // Method for common setting of particle-specific info.
+  void   initCommon();
+
+  // Useful functions for string handling.
+  string toLower(const string& name);
+  bool   boolString(string tag);
+  string attributeValue(string line, string attribute);
+  bool   boolAttributeValue(string line, string attribute);
+  int    intAttributeValue(string line, string attribute);
+  double doubleAttributeValue(string line, string attribute);
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ParticleData_H
diff --git a/PYTHIA8/pythia8140/include/ParticleDecays.h b/PYTHIA8/pythia8140/include/ParticleDecays.h
new file mode 100644 (file)
index 0000000..7b89066
--- /dev/null
@@ -0,0 +1,146 @@
+// ParticleDecays.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the classes to perform a particle decay.
+// DecayHandler: base class for external handling of decays.
+// ParticleDecays: decay a particle.
+
+#ifndef Pythia8_ParticleDecays_H
+#define Pythia8_ParticleDecays_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+#include "TimeShower.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// DecayHandler is base class for the external handling of decays.
+// There is only one pure virtual method, that should do the decay. 
+
+class DecayHandler {
+
+public:
+
+  // A pure virtual method, wherein the derived class method does a decay.
+  virtual bool decay(vector<int>& idProd, vector<double>& mProd, 
+    vector<Vec4>& pProd, int iDec, const Event& event) = 0;
+
+protected:
+
+  // Destructor.
+  virtual ~DecayHandler() {}
+
+};
+//==========================================================================
+
+// The ParticleDecays class contains the routines to decay a particle.
+
+class ParticleDecays {
+
+public:
+
+  // Constructor. 
+  ParticleDecays() {}
+
+  // Initialize: store pointers and find settings
+  void init(Info* infoPtrIn, Settings& settings, 
+    ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, 
+    TimeShower* timesDecPtrIn, StringFlav* flavSelPtrIn, 
+    DecayHandler* decayHandlePtrIn, vector<int> handledParticles); 
+  // Perform a decay of a single particle.
+  bool decay(int iDec, Event& event); 
+
+  // Did decay result in new partons to hadronize?
+  bool moreToDo() const {return hasPartons && keepPartons;}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NTRYDECAY, NTRYPICK, NTRYMEWT, NTRYDALITZ;
+  static const double MSAFEDALITZ, WTCORRECTION[11];
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*         rndmPtr;
+
+  // Pointers to timelike showers, for decays to partons (e.g. Upsilon).
+  TimeShower*   timesDecPtr;
+
+  // Pointer to class for flavour generation; needed when to pick hadrons.
+  StringFlav*   flavSelPtr;
+
+  // Pointer to a handler of external decays.
+  DecayHandler* decayHandlePtr;
+
+  // Initialization data, read from Settings.
+  bool   limitTau0, limitTau, limitRadius, limitCylinder, limitDecay, 
+         mixB, doFSRinDecays;
+  double mSafety, tau0Max, tauMax, rMax, xyMax, zMax, xBdMix, xBsMix, 
+         sigmaSoft, multIncrease, multRefMass, multGoffset, colRearrange, 
+         stopMass, sRhoDal, wRhoDal;
+
+  // Multiplicity. Decay products positions and masses.
+  bool   hasPartons, keepPartons;    
+  int    idDec, meMode, mult;
+  double scale;
+  vector<int>    iProd, idProd, cols, acols, idPartons;
+  vector<double> mProd, mInv, rndmOrd;
+  vector<Vec4>   pInv, pProd;
+  vector<FlavContainer> flavEnds;
+
+  // Pointer to particle data for currently decaying particle
+  ParticleDataEntry* decDataPtr;
+
+  // Check whether a decay is allowed, given the upcoming decay vertex.
+  bool checkVertex(Particle& decayer);
+
+  // Check for oscillations B0 <-> B0bar or B_s0 <-> B_s0bar.
+  bool oscillateB(Particle& decayer);
+
+  // Do a one-body decay.
+  bool oneBody(Event& event);
+
+  // Do a two-body decay;
+  bool twoBody(Event& event);
+
+  // Do a three-body decay;
+  bool threeBody(Event& event);
+
+  // Do a multibody decay using the M-generator algorithm.
+  bool mGenerator(Event& event); 
+
+  // Select mass of lepton pair in a Dalitz decay.
+  bool dalitzMass();
+
+  // Do kinematics of gamma* -> l- l+ in Dalitz decay.
+  bool dalitzKinematics(Event& event);
+
+  // Translate a partonic content into a set of actual hadrons.
+  bool pickHadrons();
+
+  // Set colour flow and scale in a decay explicitly to partons.
+  bool setColours(Event& event);
+  
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ParticleDecays_H
diff --git a/PYTHIA8/pythia8140/include/PartonDistributions.h b/PYTHIA8/pythia8140/include/PartonDistributions.h
new file mode 100644 (file)
index 0000000..f3030ac
--- /dev/null
@@ -0,0 +1,455 @@
+// PartonDistributions.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for parton densities.
+// PDF: base class.
+// LHAPDF: derived class for interface to the LHAPDF library.
+// GRV94L: derived class for the GRV 94L parton densities.
+// CTEQ5L: derived class for the CTEQ 5L parton densities.
+// MSTWpdf: derived class for MRST LO*, LO**, MSTW 2008 LO, NLO. 
+// CTEQ6pdf: derived class for CTEQ 6L, 6L1, 66, CT09 MC1, MC2, (MCS?).
+// ProtonPoint: unresolved proton with equivalent photon spectrum.  
+// GRVpiL: derived class for the GRV LO pion parton densities.
+// PomFix: derived class for Q2-independent Pomeron parton densities.
+// PomH1FitAB: derived class for the H1 2006 Fit A and Fit B Pomeron PDFs. 
+// PomH1Jets: derived class for the H1 2007 Jets Pomeron PDFs.
+// Lepton: derived class for parton densities inside a lepton.
+// LeptonPoint: derived class for unresolved lepton (mainly dummy).
+
+#ifndef Pythia8_PartonDistributions_H
+#define Pythia8_PartonDistributions_H
+
+#include "Basics.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Base class for parton distribution functions.
+
+class PDF {
+
+public:
+
+  // Constructor.
+  PDF(int idBeamIn = 2212) {idBeam = idBeamIn; idBeamAbs = abs(idBeam);
+    setValenceContent(); idSav = 9; xSav = -1.; Q2Sav = -1.;
+    xu = 0.; xd = 0.; xs = 0.; xubar = 0.; xdbar = 0.; xsbar = 0.; xc = 0.; 
+    xb = 0.; xg = 0.; xlepton = 0.; xgamma = 0.; xuVal = 0.; xuSea = 0.;
+    xdVal = 0.; xdSea = 0.; isSet = true; isInit = false;}
+
+  // Destructor.
+  virtual ~PDF() {}
+
+  // Confirm that PDF has been set up (important for LHAPDF and H1 Pomeron).
+  bool isSetup() {return isSet;}
+
+  // Dynamic choice of meson valence flavours for pi0, K0S, K0L, Pomeron.
+  void newValenceContent(int idVal1In, int idVal2In) {
+    idVal1 = idVal1In; idVal2 = idVal2In;}
+
+  // Allow extrapolation beyond boundaries. This is optional.
+  virtual void setExtrapolate(bool) {}
+
+  // Read out parton density
+  double xf(int id, double x, double Q2);
+
+  // Read out valence and sea part of parton densities.
+  double xfVal(int id, double x, double Q2);
+  double xfSea(int id, double x, double Q2);
+  
+protected:
+
+  // Store relevant quantities.
+  int    idBeam, idBeamAbs, idSav, idVal1, idVal2;
+  double xSav, Q2Sav;
+  double xu, xd, xs, xubar, xdbar, xsbar, xc, xb, xg, xlepton, xgamma,
+         xuVal, xuSea, xdVal, xdSea;
+  bool   isSet, isInit; 
+
+  // Resolve valence content for assumed meson. Possibly modified later.
+  void setValenceContent();
+
+  // Update parton densities.
+  virtual void xfUpdate(int id, double x, double Q2) = 0; 
+
+};
+//==========================================================================
+
+// Provide interface to the LHAPDF library of parton densities.
+
+class LHAPDF : public PDF {
+
+public:
+
+  // Constructor.
+  LHAPDF(int idBeamIn, string setName, int member,  int nSetIn = 1, 
+    Info* infoPtr = 0) : PDF(idBeamIn), nSet(nSetIn) 
+    {init( setName, member, infoPtr);} 
+
+  // Allow extrapolation beyond boundaries. This is optional.
+  void setExtrapolate(bool extrapol); 
+
+private:
+
+  // Initialization of PDF set.
+  void init(string setName, int member, Info* infoPtr);
+
+  // Update all PDF values.
+  void xfUpdate(int , double x, double Q2);
+
+  // Current set and pdf values.
+  int    nSet;
+  double xfArray[13];
+  double xPhoton;
+
+  // Keep track of latest initialized PDF, so does not have to repeat.
+  static string latestSetName;
+  static int    latestMember, latestNSet;   
+
+};
+//==========================================================================
+
+// Gives the GRV 94L (leading order) parton distribution function set
+// in parametrized form. Authors: M. Glueck, E. Reya and A. Vogt.
+
+class GRV94L : public PDF {
+
+public:
+
+  // Constructor.
+  GRV94L(int idBeamIn = 2212) : PDF(idBeamIn) {}
+
+private:
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // Auxiliary routines used during the updating.
+  double grvv (double x, double n, double ak, double bk, double a, 
+    double b, double c, double d);
+  double grvw (double x, double s, double al, double be, double ak, 
+    double bk, double a, double b, double c, double d, double e, double es);
+  double grvs (double x, double s, double sth, double al, double be, 
+    double ak, double ag, double b, double d, double e, double es);
+
+};
+//==========================================================================
+
+// Gives the CTEQ 5L (leading order) parton distribution function set
+// in parametrized form. Parametrization by J. Pumplin. Authors: CTEQ.
+
+class CTEQ5L : public PDF {
+
+public:
+
+  // Constructor.
+  CTEQ5L(int idBeamIn = 2212) : PDF(idBeamIn) {}
+
+private:
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+};
+//==========================================================================
+
+// The MSTWpdf class.
+// MRST LO*(*) and MSTW 2008 PDF's, specifically the LO one.
+// Original C++ version by Jeppe Andersen.
+// Modified by Graeme Watt <watt(at)hep.ucl.ac.uk>.
+// Sets available:
+// iFit = 1 : MRST LO*  (2007).
+// iFit = 2 : MRST LO** (2008).
+// iFit = 3 : MSTW 2008 LO, central member.
+// iFit = 4 : MSTW 2008 NLO, central member. (Warning!)
+
+class MSTWpdf : public PDF {
+
+public:
+
+  // Constructor.
+  MSTWpdf(int idBeamIn = 2212, int iFitIn = 1, string xmlPath = "../xmldoc/", 
+    Info* infoPtr = 0) : PDF(idBeamIn) {init( iFitIn,  xmlPath, infoPtr);}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    np, nx, nq, nqc0, nqb0;
+  static const double xmin, xmax, qsqmin, qsqmax, xxInit[65], qqInit[49];
+
+  // Data read in from grid file or set at initialization.
+  int    iFit, alphaSorder, alphaSnfmax;
+  double mCharm, mBottom, alphaSQ0, alphaSMZ, distance, tolerance, 
+         xx[65], qq[49], c[13][64][48][5][5];
+
+  // Initialization of data array.
+  void init( int iFitIn, string xmlPath, Info* infoPtr);
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // Evaluate PDF of one flavour species.
+  double parton(int flavour,double x,double q);
+  double parton_interpolate(int flavour,double xxx,double qqq);
+  double parton_extrapolate(int flavour,double xxx,double qqq);
+
+  // Auxiliary routines for evaluation.
+  int locate(double xx[],int n,double x);
+  double polderivative1(double x1, double x2, double x3, double y1,
+    double y2, double y3);
+  double polderivative2(double x1, double x2, double x3, double y1, 
+    double y2, double y3);
+  double polderivative3(double x1, double x2, double x3, double y1, 
+    double y2, double y3);
+
+};
+//==========================================================================
+
+// The CTEQ6pdf class.
+// Sets available:
+// iFit = 1 : CTEQ6L
+// iFit = 2 : CTEQ6L1
+// iFit = 3 : CTEQ66.00 (NLO, central member) 
+// iFit = 4 : CT09MC1
+// iFit = 5 : CT09MC2
+// iFit = 6 : CT09MCS (not yet implemented)
+
+class CTEQ6pdf : public PDF {
+
+public:
+
+  // Constructor.
+  CTEQ6pdf(int idBeamIn = 2212, int iFitIn = 1, string xmlPath = "../xmldoc/", 
+    Info* infoPtr = 0) : PDF(idBeamIn) {init( iFitIn, xmlPath, infoPtr);}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double EPSILON, XPOWER;
+
+  // Data read in from grid file or set at initialization.
+  int    iFit, order, nQuark, nfMx, mxVal, nX, nT, nG,
+         iGridX, iGridQ, iGridLX, iGridLQ;
+  double lambda, mQ[7], qIni, qMax, tv[26], xMin, xv[202], upd[57773],
+         xvpow[202], xMinEps, xMaxEps, qMinEps, qMaxEps, fVec[5],
+         tConst[9], xConst[9], xLast, qLast;
+
+  // Initialization of data array.
+  void init( int iFitIn, string xmlPath, Info* infoPtr);
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // Evaluate PDF of one flavour species.
+  double parton6(int iParton, double x, double q);
+
+  // Interpolation in grid.
+  double polint4F(double xgrid[], double fgrid[], double xin);
+
+};
+
+//==========================================================================
+
+// SA Unresolved proton: equivalent photon spectrum from
+// V.M. Budnev, I.F. Ginzburg, G.V. Meledin and V.G. Serbo, 
+// Phys. Rept. 15 (1974/1975) 181.
+
+class ProtonPoint : public PDF {
+
+public:
+
+  // Constructor.
+  ProtonPoint(int idBeamIn = 2212, Info* infoPtrIn = 0) : 
+              PDF(idBeamIn), m_infoPtr(infoPtrIn) {}
+
+private:
+
+  // Stored value for PDF choice.
+  static const double ALPHAEM, Q2MAX, Q20, A, B, C;
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // phi function from Q2 integration.
+  double phiFunc(double x, double Q);
+
+  // Info and errors
+  Info* m_infoPtr;
+
+};
+//==========================================================================
+
+// Gives the GRV 1992 pi+ (leading order) parton distribution function set
+// in parametrized form. Authors: Glueck, Reya and Vogt.
+
+class GRVpiL : public PDF {
+
+public:
+
+  // Constructor.
+  GRVpiL(int idBeamIn = 221) : PDF(idBeamIn) {}
+
+private:
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+};
+
+//==========================================================================
+
+// Gives generic Q2-independent Pomeron PDF.
+
+class PomFix : public PDF {
+
+public:
+
+  // Constructor.
+  PomFix(int idBeamIn = 990, double PomGluonAIn = 0., 
+    double PomGluonBIn = 0., double PomQuarkAIn = 0., 
+    double PomQuarkBIn = 0., double PomQuarkFracIn = 0., 
+    double PomStrangeSuppIn = 0.) : PDF(idBeamIn), 
+    PomGluonA(PomGluonAIn), PomGluonB(PomGluonBIn), 
+    PomQuarkA(PomQuarkAIn), PomQuarkB(PomQuarkBIn), 
+    PomQuarkFrac(PomQuarkFracIn), PomStrangeSupp(PomStrangeSuppIn) 
+    {init();}
+
+private:
+
+  // Stored value for PDF choice.
+  double PomGluonA, PomGluonB, PomQuarkA, PomQuarkB, PomQuarkFrac, 
+         PomStrangeSupp, normGluon, normQuark;
+
+  // Initialization of some constants.
+  void init();
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double);
+
+};
+//==========================================================================
+
+// The H1 2006 Fit A and Fit B Pomeron parametrization.
+// H1 Collaboration, A. Aktas et al., "Measurement and QCD Analysis of
+// the Diffractive Deep-Inelastic Scattering Cross Section at HERA",
+// DESY-06-049, Eur. Phys. J. C48 (2006) 715. e-Print: hep-ex/0606004.
+
+class PomH1FitAB : public PDF {
+
+public:
+
+  // Constructor.
+ PomH1FitAB(int idBeamIn = 990, int iFit = 1, double rescaleIn = 1.,
+   string xmlPath = "../xmldoc/", Info* infoPtr = 0) : PDF(idBeamIn) 
+   {rescale = rescaleIn; init( iFit, xmlPath, infoPtr);}
+
+private:
+
+  // Limits for grid in x, in Q2, and data in (x, Q2).
+  int    nx, nQ2;
+  double rescale, xlow, xupp, dx, Q2low, Q2upp, dQ2;
+  double gluonGrid[100][30];
+  double quarkGrid[100][30];
+
+  // Initialization of data array.
+  void init( int iFit, string xmlPath, Info* infoPtr);
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double );
+
+};
+//==========================================================================
+
+// The H1 2007 Jets Pomeron parametrization..
+// H1 Collaboration, A. Aktas et al., "Dijet Cross Sections and Parton     
+// Densities in Diffractive DIS at HERA", DESY-07-115, Aug 2007. 33pp.    
+// Published in JHEP 0710:042,2007. e-Print: arXiv:0708.3217 [hep-ex]  
+
+class PomH1Jets : public PDF {
+
+public:
+
+  // Constructor.
+  PomH1Jets(int idBeamIn = 990,  double rescaleIn = 1., 
+   string xmlPath = "../xmldoc/", Info* infoPtr = 0) : PDF(idBeamIn) 
+   {rescale = rescaleIn; init( xmlPath, infoPtr);}
+
+private:
+
+  // Arrays for grid in x, in Q2, and data in (x, Q2).
+  double rescale;
+  double xGrid[100];
+  double Q2Grid[88];
+  double gluonGrid[100][88];
+  double singletGrid[100][88];
+  double charmGrid[100][88];
+
+  // Initialization of data array.
+  void init( string xmlPath, Info* infoPtr);
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double );
+
+};
+//==========================================================================
+
+// Gives electron (or muon, or tau) parton distribution.
+class Lepton : public PDF {
+
+public:
+
+  // Constructor.
+  Lepton(int idBeamIn = 11) : PDF(idBeamIn) {}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double ALPHAEM, ME, MMU, MTAU;
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // The squared lepton mass, set at initialization.
+  double m2Lep;
+
+};
+//==========================================================================
+
+// Gives electron (or other lepton) parton distribution when unresolved.
+class LeptonPoint : public PDF {
+
+public:
+
+  // Constructor.
+  LeptonPoint(int idBeamIn = 11) : PDF(idBeamIn) {}
+
+private:
+
+  // Update PDF values in trivial way. 
+  void xfUpdate(int , double , double ) {xlepton = 1; xgamma = 0.;}
+
+};
+
+} // end namespace Pythia8
+//==========================================================================
+
+#endif // Pythia8_PartonDistributions_H
diff --git a/PYTHIA8/pythia8140/include/PartonLevel.h b/PYTHIA8/pythia8140/include/PartonLevel.h
new file mode 100644 (file)
index 0000000..6f5bee4
--- /dev/null
@@ -0,0 +1,163 @@
+// PartonLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main class for parton-level event generation
+// PartonLevel: administrates showers, multiple interactions and remnants.
+
+#ifndef Pythia8_PartonLevel_H
+#define Pythia8_PartonLevel_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "BeamRemnants.h"
+#include "Event.h"
+#include "Info.h"
+#include "MultipleInteractions.h"
+#include "ParticleData.h"
+#include "PartonSystems.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SpaceShower.h"
+#include "StandardModel.h"
+#include "TimeShower.h"
+#include "UserHooks.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The PartonLevel class contains the top-level routines to generate
+// the partonic activity of an event.
+
+class PartonLevel {
+
+public:
+
+  // Constructor. 
+  PartonLevel() : userHooksPtr(0) {} 
+  // Initialization of all classes at the parton level.
+  bool init( Info* infoPtrIn, Settings& settings,
+    ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, 
+    BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, 
+    BeamParticle* beamPomAPtrIn, BeamParticle* beamPomBPtrIn, 
+    CoupSM* coupSMPtrIn, PartonSystems* partonSystemsPtrIn, 
+    SigmaTotal* sigmaTotPtr, TimeShower* timesDecPtrIn, 
+    TimeShower* timesPtrIn, SpaceShower* spacePtrIn, 
+    UserHooks* userHooksPtrIn);
+  // Generate the next parton-level process.
+  bool next( Event& process, Event& event); 
+
+  // Tell whether failure was due to vetoing.
+  bool hasVetoed() const {return doVeto;}
+
+  // Accumulate and print statistics.
+  void accumulate() {multiPtr->accumulate();}
+  void statistics(bool reset = false) {
+    if (doMI) multiMB.statistics(reset);}
+    // For now no separate statistics for diffraction??
+    //if (doMISDA && doDiffraction) multiSDA.statistics(reset); 
+    //if (doMISDB && doDiffraction) multiSDB.statistics(reset);}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int NTRY;
+
+  // Initialization data, mainly read from Settings.
+  bool   doMinBias, doDiffraction, doMI, doMIMB, doMISDA, doMISDB, doMIinit, 
+         doISR, doFSRduringProcess, doFSRafterProcess,  doFSRinResonances, 
+         doRemnants, doSecondHard, hasLeptonBeams, hasPointLeptons, 
+         canVetoPT, canVetoStep, canVetoMIStep, canSetScale;
+  double mMinDiff, mWidthDiff;
+
+  // Event generation strategy. Number of steps. Maximum pT scales.
+  bool   doVeto;
+  int    nMI, nISR, nFSRinProc, nFSRinRes, nISRhard, nFSRhard, 
+         typeLatest, nVetoStep, typeVetoStep, nVetoMIStep, iSysNow;
+  double pTsaveMI, pTsaveISR, pTsaveFSR, pTvetoPT;
+
+  // Current event properties.
+  bool   isMinBias, isDiffA, isDiffB, isDiff, isSingleDiff, isDoubleDiff, 
+         isResolved, isResolvedA, isResolvedB;
+  int    sizeProcess, sizeEvent;
+  double eCMsave; 
+
+  // Pointer to various information on the generation.
+  Info*          infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData*  particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*          rndmPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle*  beamAPtr;
+  BeamParticle*  beamBPtr;
+
+  // Spare copies of normal pointers. Pointers to Pomeron beam-inside-beam.
+  BeamParticle*  beamHadAPtr;  
+  BeamParticle*  beamHadBPtr;  
+  BeamParticle*  beamPomAPtr;
+  BeamParticle*  beamPomBPtr;
+
+  // Pointers to Standard Model couplings.
+  CoupSM*        coupSMPtr;
+  
+  // Pointer to information on subcollision parton locations.
+  PartonSystems* partonSystemsPtr;
+
+  // Pointer to userHooks object for user interaction with program.
+  UserHooks*     userHooksPtr;
+
+  // Pointers to timelike showers for resonance decays and the rest.
+  TimeShower*    timesDecPtr;
+  TimeShower*    timesPtr;
+
+  // Pointer to spacelike showers.
+  SpaceShower*   spacePtr;
+
+  // The generator classes for multiple interactions.
+  MultipleInteractions  multiMB;
+  MultipleInteractions  multiSDA;
+  MultipleInteractions  multiSDB;
+  MultipleInteractions* multiPtr;
+
+  // The generator class to construct beam-remnant kinematics. 
+  BeamRemnants remnants;
+
+  // Resolved diffraction: find how many systems should have it.
+  int decideResolvedDiff( Event& process);
+
+  // Set up an unresolved process, i.e. elastic or diffractive.
+  bool setupUnresolvedSys( Event& process, Event& event);
+
+  // Set up the hard process, excluding subsequent resonance decays.
+  void setupHardSys( int iHardLoop, Event& process, Event& event);
+  // Keep track of how much of hard process has been handled.
+  int nHardDone;
+
+  // Resolved diffraction: pick whether to have it and set up for it.
+  void setupResolvedDiff( int iHardLoop, Event& process);
+
+  // Resolved diffraction: restore normal behaviour.
+  void leaveResolvedDiff( int iHardLoop, Event& event);
+
+  // Perform showers in resonance decay chains.
+  bool resonanceShowers( Event& process, Event& event); 
+
+  // Position in main event record of hard partons before showers.
+  vector<int> iPosBefShow;
+  
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PartonLevel_H
diff --git a/PYTHIA8/pythia8140/include/PartonSystems.h b/PYTHIA8/pythia8140/include/PartonSystems.h
new file mode 100644 (file)
index 0000000..e6e1fdd
--- /dev/null
@@ -0,0 +1,95 @@
+// PartonSystems.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains auxiliary classes for the parton-level processes.
+// PartonSystem contains info on a single partonic subcollision.
+// PartonSystems describes the set of subcollisions in the whole event.
+
+#ifndef Pythia8_PartonSystems_H
+#define Pythia8_PartonSystems_H
+
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The PartonSystem class contains info on an individual singlet.
+// Only to be used inside PartonSystems, so no private members. 
+
+class PartonSystem {
+  
+public:
+
+  // Constructors.
+  PartonSystem() : iInA(0), iInB(0), sHat(0.) {iOut.reserve(10);}
+
+  // Stored quantities. 
+  int         iInA, iInB; 
+  vector<int> iOut;
+  double      sHat;
+  
+};
+//==========================================================================
+
+// The PartonSystems class describes the whole set of subcollisions.
+
+class PartonSystems {
+
+public:
+
+  // Constructor.
+  PartonSystems() {systems.resize(0);}
+
+  // Reset system list to empty.
+  void clear() {systems.resize(0);}
+
+  // Add new subsystem to list; return its index. Number of subsystems. 
+  int addSys() {systems.push_back(PartonSystem()); 
+    return systems.size() - 1;} 
+  int sizeSys() const {return systems.size();}
+
+  // Set, add or replace info to one system. 
+  void setInA(int iSys, int iPos) {systems[iSys].iInA = iPos;}  
+  void setInB(int iSys, int iPos) {systems[iSys].iInB = iPos;}  
+  void addOut(int iSys, int iPos) {systems[iSys].iOut.push_back(iPos);} 
+  void setOut(int iSys, int iMem, int iPos) {systems[iSys].iOut[iMem] = iPos;} 
+  void replace(int iSys, int iPosOld, int iPosNew);
+  void setSHat(int iSys, double sHatIn) {systems[iSys].sHat = sHatIn;}
+
+  // Get info on one system.
+  bool hasInAB(int iSys)         const {return ( (systems[iSys].iInA > 0)   
+                                       || (systems[iSys].iInB > 0) ) ;}
+  int getInA(int iSys)           const {return systems[iSys].iInA;}
+  int getInB(int iSys)           const {return systems[iSys].iInB;}
+  int sizeOut(int iSys)          const {return systems[iSys].iOut.size();}
+  int getOut(int iSys, int iMem) const {return systems[iSys].iOut[iMem];} 
+  int sizeAll(int iSys)          const {return (hasInAB(iSys)) 
+    ? systems[iSys].iOut.size() + 2 : systems[iSys].iOut.size();}
+  int getAll(int iSys, int iMem) const; 
+  double getSHat(int iSys)       const {return systems[iSys].sHat;} 
+
+  // Find system of given outgoing parton, optionally also incoming one.
+  int getSystemOf(int iPos, bool alsoIn = false) const;  
+
+  // Find iOut index of given system and event record index
+  int getIndexOfOut(int iSys, int iPos) const;  
+
+  // List all current systems.
+  void list(ostream& os = cout) const;
+
+private:
+  // List of all separate partonic subsystems.
+  vector<PartonSystem> systems;
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PartonSystems_H
diff --git a/PYTHIA8/pythia8140/include/PhaseSpace.h b/PYTHIA8/pythia8140/include/PhaseSpace.h
new file mode 100644 (file)
index 0000000..f143757
--- /dev/null
@@ -0,0 +1,514 @@
+// PhaseSpace.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for phase space generators in kinematics selection.
+// PhaseSpace: base class for phase space generators.
+// Base class for derived classes> 2 ->1 , 2 -> 2, 2 -> 2 elastic/diffractive,
+// 2 -> 2 minbias, 2 -> 3, Les Houches. 
+
+#ifndef Pythia8_PhaseSpace_H
+#define Pythia8_PhaseSpace_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Info.h"
+#include "LesHouches.h"
+#include "MultipleInteractions.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PythiaStdlib.h"
+#include "SigmaProcess.h"
+#include "SigmaTotal.h"
+#include "Settings.h"
+#include "StandardModel.h"
+#include "UserHooks.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Forward reference to the UserHooks class.
+class UserHooks;
+//==========================================================================
+
+// PhaseSpace is a base class for  phase space generators 
+// used in the selection of hard-process kinematics.
+
+class PhaseSpace {
+
+public:
+
+  // Destructor.
+  virtual ~PhaseSpace() {}
+
+  // Perform simple initialization and store pointers.
+  void init(bool isFirst, SigmaProcess* sigmaProcessPtrIn, 
+    Info* infoPtrIn, Settings* settingsPtrIn, ParticleData* particleDataPtrIn,  
+    Rndm* rndmPtrIn, BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, 
+    CoupSM* coupSMPtrIn, SigmaTotal* sigmaTotPtrIn, UserHooks* userHooksPtrIn);
+
+  // Update the CM energy of the event.
+  void newECM(double eCMin) {eCM = eCMin; s = eCM * eCM;}
+
+  // Store or replace Les Houches pointer.
+  void setLHAPtr(LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;}  
+
+  // A pure virtual method, wherein an optimization procedure
+  // is used to determine how phase space should be sampled.
+  virtual bool setupSampling() = 0; 
+
+  // A pure virtual method, wherein a trial event kinematics 
+  // is to be selected in the derived class
+  virtual bool trialKin(bool inEvent = true, bool repeatSame = false) = 0; 
+
+  // A pure virtual method, wherein the accepted event kinematics 
+  // is to be constructed in the derived class
+  virtual bool finalKin() = 0; 
+
+  // Allow for nonisotropic decays when ME's available.
+  void   decayKinematics( Event& process);
+
+  // Give back current or maximum cross section, or set latter.
+  double sigmaNow() const {return sigmaNw;}
+  double sigmaMax() const {return sigmaMx;}
+  bool   newSigmaMax() const {return newSigmaMx;}
+  void   setSigmaMax(double sigmaMaxIn) {sigmaMx = sigmaMaxIn;}
+
+  // For Les Houches with negative event weight needs 
+  virtual double sigmaSumSigned() const {return sigmaMx;}
+  
+  // Give back constructed four-vectors and known masses.
+  Vec4   p(int i)   const {return pH[i];} 
+  double m(int i)   const {return mH[i];}
+
+  // Give back other event properties.
+  double ecm()      const {return eCM;}
+  double x1()       const {return x1H;}
+  double x2()       const {return x2H;}
+  double sHat()     const {return sH;}
+  double tHat()     const {return tH;}
+  double uHat()     const {return uH;}
+  double pTHat()    const {return pTH;}
+  double thetaHat() const {return theta;}
+  double phiHat()   const {return phi;}
+  double runBW3()   const {return runBW3H;}
+  double runBW4()   const {return runBW4H;}
+  double runBW5()   const {return runBW5H;}
+
+  // Inform whether beam particles are resolved in partons or scatter directly.
+  virtual bool isResolved() const {return true;}
+
+protected:
+
+  // Constructor.
+  PhaseSpace() {}
+
+  // Constants: could only be changed in the code itself.
+  static const int    NMAXTRY, NTRY3BODY;
+  static const double SAFETYMARGIN, TINY, EVENFRAC, SAMESIGMA, WIDTHMARGIN, 
+                      SAMEMASS, MASSMARGIN, EXTRABWWTMAX, THRESHOLDSIZE, 
+                      THRESHOLDSTEP, YRANGEMARGIN, LEPTONXMIN, LEPTONXMAX, 
+                      LEPTONXLOGMIN, LEPTONXLOGMAX, LEPTONTAUMIN,
+                      SHATMINZ, PT2RATMINZ, WTCORRECTION[11];
+
+  // Pointer to cross section. 
+  SigmaProcess* sigmaProcessPtr; 
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the settings database.
+  Settings*     settingsPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*         rndmPtr;
+
+  // Pointers to incoming beams.
+  BeamParticle* beamAPtr;
+  BeamParticle* beamBPtr;
+
+  // Pointer to Standard Model couplings.
+  CoupSM*         coupSMPtr;
+  
+  // Pointer to the total/elastic/diffractive cross section object.
+  SigmaTotal*   sigmaTotPtr;
+
+  // Pointer to userHooks object for user interaction with program.
+  UserHooks*    userHooksPtr;
+
+  // Pointer to LHAup for generating external events.
+  LHAup*        lhaUpPtr;
+
+  // Initialization data, normally only set once.
+  bool   useBreitWigners, doEnergySpread, showSearch, showViolation,
+         increaseMaximum;
+  int    gmZmodeGlobal;
+  double mHatGlobalMin, mHatGlobalMax, pTHatGlobalMin, pTHatGlobalMax, 
+         pTHatMinDiverge, minWidthBreitWigners;
+  // Information on incoming beams.
+  int    idA, idB;
+  double mA, mB, eCM, s; 
+  bool   hasLeptonBeams, hasPointLeptons;
+
+ // Cross section information.
+  bool   newSigmaMx, canModifySigma;
+  int    gmZmode;
+  double wtBW, sigmaNw, sigmaMx, sigmaPos, sigmaNeg;
+
+  // Process-specific kinematics properties, almost always available.
+  double mHatMin, mHatMax, sHatMin, sHatMax, pTHatMin, pTHatMax, 
+         pT2HatMin, pT2HatMax; 
+
+  // Event-specific kinematics properties, almost always available.
+  double x1H, x2H, m3, m4, m5, s3, s4, s5, mHat, sH, tH, uH, pAbs, p2Abs, 
+         pTH, theta, phi, betaZ;
+  Vec4   pH[6];
+  double mH[6];
+
+  // Reselect decay products momenta isotropically in phase space.
+  void decayKinematicsStep( Event& process, int iRes);
+
+  // Much common code for normal 2 -> 1, 2 -> 2 and 2 -> 3 cases:
+
+  // Determine how phase space should be sampled.
+  void setup3Body();
+  bool setupSampling123(bool is2, bool is3, ostream& os = cout); 
+
+  // Select a trial kinematics phase space point.
+  bool trialKin123(bool is2, bool is3, bool inEvent = true, ostream& os = cout); 
+
+  // Presence and properties of any s-channel resonances.
+  int    idResA, idResB;
+  double mResA, mResB, GammaResA, GammaResB, tauResA, tauResB, widResA, 
+         widResB;
+  bool   sameResMass;
+
+  // Kinematics properties specific to 2 -> 1/2/3.
+  bool   useMirrorWeight; 
+  double tau, y, z, tauMin, tauMax, yMax, zMin, zMax, ratio34, unity34, 
+         zNeg, zPos, wtTau, wtY, wtZ, wt3Body, runBW3H, runBW4H, runBW5H, 
+         intTau0, intTau1, intTau2, intTau3, intTau4, intTau5, intTau6, 
+         intY0, intY12, intY34, intY56, mTchan1, sTchan1, mTchan2, sTchan2, 
+         frac3Flat, frac3Pow1, frac3Pow2; 
+  Vec4   p3cm, p4cm, p5cm;
+
+  // Coefficients for optimized selection in 2 -> 1/2/3.
+  int    nTau, nY, nZ;
+  double tauCoef[8], yCoef[8], zCoef[8], tauCoefSum[8], yCoefSum[8], 
+         zCoefSum[8];
+
+  // Calculate kinematical limits for 2 -> 1/2/3.
+  bool limitTau(bool is2, bool is3);
+  bool limitY();
+  bool limitZ();
+
+  // Select kinematical variable between defined limits for 2 -> 1/2/3.
+  void selectTau(int iTau, double tauVal, bool is2);
+  void selectY(int iY, double yVal);
+  void selectZ(int iZ, double zVal);
+  bool select3Body();
+
+  // Solve equation system for better phase space coefficients in 2 -> 1/2/3.
+  void solveSys( int n, int bin[8], double vec[8], double mat[8][8],
+    double coef[8], ostream& os = cout); 
+
+  // Properties specific to resonance mass selection in 2 -> 2 and 2 -> 3.
+  bool   useBW[6]; 
+  int    idMass[6];
+  double mPeak[6], sPeak[6], mWidth[6], mMin[6], mMax[6], mw[6], wmRat[6], 
+         mLower[6], mUpper[6], sLower[6], sUpper[6], fracFlat[6], fracInv[6], 
+         fracInv2[6], atanLower[6], atanUpper[6], intBW[6], intFlat[6], 
+         intInv[6], intInv2[6]; 
+
+  // Setup mass selection for one resonance at a time. Split in two parts.
+  void   setupMass1(int iM);
+  void   setupMass2(int iM, double distToThresh);
+
+  // Do mass selection and find the associated weight.
+  void   trialMass(int iM);
+  double weightMass(int iM);
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 1 kinematics set up in tau, y.
+
+class PhaseSpace2to1tauy : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to1tauy() {}
+
+  // Optimize subsequent kinematics selection.
+  virtual bool setupSampling() {if (!setupMass()) return false;
+    return setupSampling123(false, false);} 
+
+  // Construct the trial kinematics.
+  virtual bool trialKin(bool inEvent = true, bool = false) {wtBW = 1.; 
+    return trialKin123(false, false, inEvent);}
+
+  // Construct the final event kinematics.
+  virtual bool finalKin();
+
+private:
+
+  // Set up allowed mass range.
+  bool setupMass();
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 2 kinematics set up in tau, y, z = cos(theta).
+
+class PhaseSpace2to2tauyz : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to2tauyz() {}
+
+  // Optimize subsequent kinematics selection.
+  virtual bool setupSampling() {if (!setupMasses()) return false; 
+    return setupSampling123(true, false);} 
+
+  // Construct the trial kinematics.
+  virtual bool trialKin(bool inEvent = true, bool = false) {
+    if (!trialMasses()) return false; 
+    return trialKin123(true, false, inEvent);}
+
+  // Construct the final event kinematics.
+  virtual bool finalKin();
+
+private:
+
+  // Set up for fixed or Breit-Wigner mass selection.
+  bool setupMasses();
+
+  // Select fixed or Breit-Wigner-distributed masses.
+  bool trialMasses();
+
+  // Pick off-shell initialization masses when on-shell not allowed.
+  bool constrainedM3M4();
+  bool constrainedM3();
+  bool constrainedM4();
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 2 kinematics set up for elastic scattering.
+
+class PhaseSpace2to2elastic : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to2elastic() {}
+
+  // Construct the trial or final event kinematics.
+  virtual bool setupSampling(); 
+  virtual bool trialKin(bool inEvent = true, bool = false); 
+  virtual bool finalKin(); 
+
+  // Are beam particles resolved in partons or scatter directly?
+  virtual bool isResolved() const {return false;}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const double EXPMAX, CONVERTEL;
+
+  // Kinematics properties specific to 2 -> 2 elastic.
+  bool   useCoulomb;
+  double s1, s2, bSlope, lambda12S, tLow, tUpp, tAux, sigmaTot, rho,
+         lambda, tAbsMin, phaseCst, alphaEM0, sigmaNuc, sigmaCou, signCou;
+
+ // Calculation of alphaElectromagnetic.
+ AlphaEM alphaEM;
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 2 kinematics set up for diffractive scattering.
+
+class PhaseSpace2to2diffractive : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to2diffractive(bool isDiffAin = false, bool isDiffBin = false)
+    : isDiffA(isDiffAin), isDiffB(isDiffBin) {}
+
+  // Construct the trial or final event kinematics.
+  virtual bool setupSampling(); 
+  virtual bool trialKin(bool inEvent = true, bool = false); 
+  virtual bool finalKin(); 
+
+  // Are beam particles resolved in partons or scatter directly?
+  virtual bool isResolved() const {return false;}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    NTRY;
+  static const double EXPMAX, DIFFMASSMAX;
+
+  // Initialization data, in constructor or read from Settings.
+  bool   isDiffA, isDiffB;
+  int    PomFlux;
+  double epsilonPF, alphaPrimePF;
+
+  // Initialization: kinematics properties specific to 2 -> 2 diffractive.
+  double m3ElDiff, m4ElDiff, s1, s2, lambda12, lambda34, tLow, tUpp,
+         cRes, sResXB, sResAX, sProton, bMin, bSlope, bSlope1, bSlope2, 
+         probSlope1, xIntPF, xtCorPF, mp24DL, coefDL, tAux, tAux1, tAux2;
+
+};
+//==========================================================================
+
+// A derived class for minumum bias events. Hardly does anything, since
+// the real action is taken care of by the MultipleInteractions class.
+
+class PhaseSpace2to2minbias : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to2minbias() {}
+
+  // Construct the trial or final event kinematics.
+  virtual bool setupSampling() {sigmaNw = sigmaProcessPtr->sigmaHat();
+    sigmaMx = sigmaNw; return true;}
+  virtual bool trialKin( bool , bool = false) {return true;}  
+  virtual bool finalKin() {return true;}
+
+private:
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 3 kinematics 1 + 2 -> 3 + 4 + 5 set up in 
+// tau, y, pT2_4, pT2_5, phi_4, phi_5 and y_3 (partial cylindrical symmetry).
+
+class PhaseSpace2to3tauycyl : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to3tauycyl() {}
+
+  // Optimize subsequent kinematics selection.
+  virtual bool setupSampling() {if (!setupMasses()) return false; 
+    setup3Body(); return setupSampling123(false, true);} 
+
+  // Construct the trial kinematics.
+  virtual bool trialKin(bool inEvent = true, bool = false) {
+    if (!trialMasses()) return false; 
+    return trialKin123(false, true, inEvent);}
+
+  // Construct the final event kinematics.
+  virtual bool finalKin();
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    NITERNR;
+
+  // Set up for fixed or Breit-Wigner mass selection.
+  bool setupMasses();
+
+  // Select fixed or Breit-Wigner-distributed masses.
+  bool trialMasses();
+
+};
+//==========================================================================
+
+// A derived class with 2 -> 3 kinematics 1 + 2 -> 3 + 4 + 5 set up in 
+// y3, y4, y5, pT2_3, pT2_5, phi_3 and phi_5, and with R separation cut.
+// Intended specifically for (essentially massless) 2 -> 3 QCD processes.
+
+class PhaseSpace2to3yyycyl : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpace2to3yyycyl() {}
+
+  // Optimize subsequent kinematics selection.
+  virtual bool setupSampling(); 
+
+  // Construct the trial kinematics.
+  virtual bool trialKin(bool inEvent = true, bool = false); 
+
+  // Construct the final event kinematics.
+  virtual bool finalKin();
+
+private:
+
+  // Phase space cuts specifically for 2 -> 3 QCD processes.
+  double pTHat3Min, pTHat3Max, pTHat5Min, pTHat5Max, RsepMin, R2sepMin;
+  bool   hasBaryonBeams;
+
+  // Event kinematics choices.
+  double pT3Min, pT3Max, pT5Min, pT5Max, y3Max, y4Max, y5Max,
+         pT3, pT4, pT5, phi3, phi4, phi5, y3, y4, y5, dphi;
+  Vec4   pInSum;
+
+};
+
+//==========================================================================
+
+// A derived class for Les Houches events. 
+
+class PhaseSpaceLHA : public PhaseSpace {
+
+public:
+
+  // Constructor.
+  PhaseSpaceLHA() {idProcSave = 0;}
+
+  // Find maximal cross section for comparison with internal processes.
+  virtual bool setupSampling();
+
+  // Construct the next process, by interface to Les Houches class.
+  virtual bool trialKin( bool , bool repeatSame = false); 
+
+  // Set scale, alpha_s and alpha_em if not done.
+  virtual bool finalKin() {sigmaProcessPtr->setScale(); return true;}
+
+  // For Les Houches with negative event weight needs 
+  virtual double sigmaSumSigned() const {return sigmaSgn;}
+
+private:
+
+  // Constants.
+  static const double CONVERTPB2MB;
+
+  // Local properties.
+  int    strategy, stratAbs, nProc, idProcSave;
+  double xMaxAbsSum, xSecSgnSum, sigmaSgn;
+  vector<int>    idProc;
+  vector<double> xMaxAbsProc;
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PhaseSpace_H
diff --git a/PYTHIA8/pythia8140/include/ProcessContainer.h b/PYTHIA8/pythia8140/include/ProcessContainer.h
new file mode 100644 (file)
index 0000000..f9e9fc6
--- /dev/null
@@ -0,0 +1,180 @@
+// ProcessContainer.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the collected machinery of a process.
+// ProcessContainer: contains information on a particular process.
+// SetupContainers: administrates the selection/creation of processes.
+
+#ifndef Pythia8_ProcessContainer_H
+#define Pythia8_ProcessContainer_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Event.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PhaseSpace.h"
+#include "PythiaStdlib.h"
+#include "ResonanceDecays.h"
+#include "Settings.h"
+#include "SigmaProcess.h"
+#include "SigmaTotal.h"
+#include "StandardModel.h"
+#include "SusyCouplings.h"
+#include "SusyLesHouches.h"
+#include "UserHooks.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// The ProcessContainer class combines pointers to matrix element and 
+// phase space generator with general generation info. 
+
+class ProcessContainer {
+
+public:
+
+  // Constructor. 
+  ProcessContainer(SigmaProcess* sigmaProcessPtrIn = 0, 
+    bool externalPtrIn = false) : sigmaProcessPtr(sigmaProcessPtrIn), 
+    externalPtr(externalPtrIn), phaseSpacePtr(0) {} 
+
+  // Destructor. Do not destroy external sigmaProcessPtr.
+  ~ProcessContainer() {delete phaseSpacePtr; 
+    if (!externalPtr) delete sigmaProcessPtr;}
+  
+  // Initialize phase space and counters.
+  bool init(bool isFirst, Info* infoPtrIn, Settings& settings, 
+    ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, BeamParticle* beamAPtr, 
+    BeamParticle* beamBPtr, CoupSM* coupSMPtr, SigmaTotal* sigmaTotPtr, 
+    CoupSUSY* coupSUSYPtr, ResonanceDecays* resDecaysPtrIn, 
+    SusyLesHouches* slhaPtr, UserHooks* userHooksPtr); 
+
+  // Store or replace Les Houches pointer.
+  void setLHAPtr( LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;
+    if (sigmaProcessPtr > 0) sigmaProcessPtr->setLHAPtr(lhaUpPtr); 
+    if (phaseSpacePtr > 0) phaseSpacePtr->setLHAPtr(lhaUpPtr);}
+
+  // Update the CM energy of the event.
+  void newECM(double eCM) {phaseSpacePtr->newECM(eCM);}
+
+  // Generate a trial event; accepted or not.
+  bool trialProcess(); 
+  
+  // Give the hard subprocess (with option for a second hard subprocess).
+  bool constructProcess( Event& process, bool isHardest = true); 
+
+  // Do resonance decays.
+  bool decayResonances( Event& process); 
+
+  // Accumulate statistics after user veto.
+  void accumulate() {++nAcc;}
+
+  // Reset statistics on events generated so far.
+  void reset();
+
+  // Process name and code, and the number of final-state particles.
+  string name()        const {return sigmaProcessPtr->name();}
+  int    code()        const {return sigmaProcessPtr->code();}
+  int    nFinal()      const {return sigmaProcessPtr->nFinal();}
+  bool   isSUSY()      const {return sigmaProcessPtr->isSUSY();}
+
+  // Member functions for info on generation process.
+  bool   newSigmaMax() const {return newSigmaMx;}
+  double sigmaMax()    const {return sigmaMx;}
+  long   nTried()      const {return nTry;}
+  long   nSelected()   const {return nSel;}
+  long   nAccepted()   const {return nAcc;}
+  double sigmaSelMC()  {if (nTry > nTryStat) sigmaDelta(); return sigmaAvg;}
+  double sigmaMC()     {if (nTry > nTryStat) sigmaDelta(); return sigmaFin;}
+  double deltaMC()     {if (nTry > nTryStat) sigmaDelta(); return deltaFin;} 
+
+  // Some kinematics quantities.
+  int    id1()         const {return sigmaProcessPtr->id(1);}
+  int    id2()         const {return sigmaProcessPtr->id(2);}
+  double x1()          const {return phaseSpacePtr->x1();}
+  double x2()          const {return phaseSpacePtr->x2();}
+  double Q2Fac()       const {return sigmaProcessPtr->Q2Fac();}
+  double mHat()        const {return sqrtpos(phaseSpacePtr->sHat());}
+  double pTHat()       const {return phaseSpacePtr->pTHat();}
+  // Tell whether container is for Les Houches events.
+  bool   isLHAContainer() const {return isLHA;}
+
+  // When two hard processes set or get info whether process is matched.
+  void   isSame( bool isSameIn) { isSameSave = isSameIn;}
+  bool   isSame()      const {return isSameSave;}
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int N12SAMPLE, N3SAMPLE;
+
+  // Pointer to the subprocess matrix element. Mark if external.
+  SigmaProcess*    sigmaProcessPtr;
+  bool             externalPtr;
+
+  // Pointer to the phase space generator.
+  PhaseSpace*      phaseSpacePtr;
+
+  // Pointer to various information on the generation.
+  Info*            infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData*    particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*            rndmPtr;
+
+  // Pointer to ResonanceDecays object for sequential resonance decays.
+  ResonanceDecays* resDecaysPtr;
+
+  // Pointer to LHAup for generating external events.
+  LHAup*           lhaUpPtr;
+
+  // Info on process.
+  bool   isLHA, isMinBias, isResolved, isDiffA, isDiffB, isQCD3body,
+         allowNegSig, hasOctetOnium, isSameSave, increaseMaximum;
+  int    lhaStrat, lhaStratAbs;
+
+  // Statistics on generation process. (Long integers just in case.)
+  bool   newSigmaMx;
+  long   nTry, nSel, nAcc, nTryStat;  
+  double sigmaMx, sigmaSgn, sigmaSum, sigma2Sum, sigmaNeg, sigmaAvg, 
+         sigmaFin, deltaFin;
+
+  // Estimate integrated cross section and its uncertainty. 
+  void sigmaDelta();
+
+};
+//==========================================================================
+
+// The SetupContainers class turns the list of user-requested processes
+// into a vector of ProcessContainer objects, each with a process.
+
+class SetupContainers {
+
+public:
+
+  // Constructor. 
+  SetupContainers() {} 
+  // Initialization assuming all necessary data already read.
+  bool init(vector<ProcessContainer*>& containerPtrs, Settings& settings,
+    ParticleData* particleDataPtr, CoupSUSY& coupSUSY);
+  // Initialization of a second hard process.
+  bool init2(vector<ProcessContainer*>& container2Ptrs, Settings& settings);
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ProcessContainer_H
diff --git a/PYTHIA8/pythia8140/include/ProcessLevel.h b/PYTHIA8/pythia8140/include/ProcessLevel.h
new file mode 100644 (file)
index 0000000..941c762
--- /dev/null
@@ -0,0 +1,152 @@
+// ProcessLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main class for process-level event generation.
+// ProcessLevel: administrates the selection of "hard" process.
+
+#ifndef Pythia8_ProcessLevel_H
+#define Pythia8_ProcessLevel_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Event.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "ProcessContainer.h"
+#include "PythiaStdlib.h"
+#include "ResonanceDecays.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SusyCouplings.h"
+#include "SusyLesHouches.h"
+#include "StandardModel.h"
+#include "UserHooks.h"
+
+namespace Pythia8 {
+  
+//==========================================================================
+
+// The ProcessLevel class contains the top-level routines to generate
+// the characteristic "hard" process of an event.
+
+class ProcessLevel {
+
+public:
+
+  // Constructor. 
+  ProcessLevel() : iLHACont(-1) {} 
+
+  // Destructor to delete processes in containers.
+  ~ProcessLevel();
+  // Initialization.
+  bool init( Info* infoPtrIn, Settings& settings,
+    ParticleData* particleDataPtrIn, Rndm* rndmPtrIn, 
+    BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn, CoupSM* CoupSMPtrIn, 
+    SigmaTotal* sigmaTotPtrIn, bool doLHAin, SusyLesHouches* slhaPtrIn, 
+    UserHooks* userHooksPtrIn, vector<SigmaProcess*>& sigmaPtrs, 
+    ostream& os = cout);
+
+  // Store or replace Les Houches pointer.
+  void setLHAPtr( LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;
+  if (iLHACont >= 0) containerPtrs[iLHACont]->setLHAPtr(lhaUpPtr);}
+  // Generate the next "hard" process.
+  bool next( Event& process); 
+
+  // Accumulate and update statistics (after possible user veto).
+  void accumulate();
+
+  // Print statistics on cross sections and number of events.
+  void statistics(bool reset = false, ostream& os = cout);
+
+  // Add any junctions to the process event record list. 
+  void findJunctions( Event& junEvent);
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int MAXLOOP;
+
+  // Generic info for process generation.
+  bool   doSecondHard, doSameCuts, allHardSame, noneHardSame, 
+         someHardSame, cutsAgree, cutsOverlap, doResDecays;
+  int    nImpact, startColTag;
+  double mHatMin1, mHatMax1, pTHatMin1, pTHatMax1, mHatMin2, mHatMax2, 
+         pTHatMin2, pTHatMax2, sigmaND, sumImpactFac, sum2ImpactFac;
+
+  // Vector of containers of internally-generated processes.
+  vector<ProcessContainer*> containerPtrs;
+  int    iContainer, iLHACont;
+  double sigmaMaxSum;
+
+  // Ditto for optional choice of a second hard process.
+  vector<ProcessContainer*> container2Ptrs;
+  int    i2Container;
+  double sigma2MaxSum;
+
+  // Pointer to various information on the generation.
+  Info*           infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData*   particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*           rndmPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle*   beamAPtr;
+  BeamParticle*   beamBPtr;
+
+  // Pointer to Standard Model couplings, including alphaS and alphaEM.
+  CoupSM*         coupSMPtr;
+
+  // Pointer to SigmaTotal object needed to handle soft QCD processes.
+  SigmaTotal*     sigmaTotPtr;
+
+  // The CoupSUSY object needed to handle SUSY processes.
+  CoupSUSY        coupSUSY;
+
+  // Pointer to SusyLesHouches object for interface to SUSY spectra.
+  SusyLesHouches* slhaPtr;
+
+  // Pointer to userHooks object for user interaction with program.
+  UserHooks*      userHooksPtr;
+
+  // Pointer to LHAup for generating external events.
+  LHAup*          lhaUpPtr;
+
+  // Initialization routine for SUSY spectra.
+  bool initSLHA(Settings& settings);
+
+  // ResonanceDecay object does sequential resonance decays.
+  ResonanceDecays resonanceDecays;
+
+  // Generate the next event with one interaction.
+  bool nextOne( Event& process);
+
+  // Generate the next event with two hard interactions.
+  bool nextTwo( Event& process);
+
+  // Append the second to the first process list.
+  void combineProcessRecords( Event& process, Event& process2);
+
+  // Check that colours match up.
+  bool checkColours( Event& process);
+
+  // Print statistics when two hard processes allowed.
+  void statistics2(bool reset, ostream& os = cout);
+
+  // Statistics for Les Houches event classification.
+  vector<int> codeLHA, nEvtLHA;
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ProcessLevel_H
diff --git a/PYTHIA8/pythia8140/include/Pythia.h b/PYTHIA8/pythia8140/include/Pythia.h
new file mode 100644 (file)
index 0000000..e59c35a
--- /dev/null
@@ -0,0 +1,303 @@
+// Pythia.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main class for event generation.
+// Pythia: provide the main user interface to everything else.
+
+#ifndef Pythia8_Pythia_H
+#define Pythia8_Pythia_H
+
+#include "Analysis.h"
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "BeamShape.h"
+#include "Event.h"
+#include "FragmentationFlavZpT.h"
+#include "HadronLevel.h"
+#include "Info.h"
+#include "LesHouches.h"
+#include "PartonLevel.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PartonSystems.h"
+#include "ProcessLevel.h"
+#include "PythiaStdlib.h"
+#include "ResonanceWidths.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SpaceShower.h"
+#include "StandardModel.h"
+#include "SusyLesHouches.h"
+#include "TimeShower.h"
+#include "UserHooks.h"
+
+namespace Pythia8 {
+//==========================================================================
+
+// The Pythia class contains the top-level routines to generate an event.
+
+class Pythia {
+
+public:
+
+  // Constructor. (See Pythia.cc file.)
+  Pythia(string xmlDir = "../xmldoc");
+
+  // Destructor. (See Pythia.cc file.)
+  ~Pythia();
+
+  // Read in one update for a setting or particle data from a single line.
+  bool readString(string, bool warn = true); 
+  // Read in updates for settings or particle data from user-defined file.
+  bool readFile(string fileName, bool warn = true, 
+    int subrun = SUBRUNDEFAULT);
+  bool readFile(string fileName, int subrun) {
+    return readFile(fileName, true, subrun);}
+  bool readFile(istream& is = cin, bool warn = true, 
+    int subrun = SUBRUNDEFAULT);
+  bool readFile(istream& is, int subrun) {
+    return readFile(is, true, subrun);}
+
+  // Possibility to pass in pointers to PDF's.
+  bool setPDFPtr( PDF* pdfAPtrIn, PDF* pdfBPtrIn, PDF* pdfHardAPtrIn = 0, 
+    PDF* pdfHardBPtrIn = 0, PDF* pdfPomAPtrIn = 0, PDF* pdfPomBPtrIn = 0);
+
+  // Possibility to pass in pointer for external handling of some decays.
+  bool setDecayPtr( DecayHandler* decayHandlePtrIn, 
+    vector<int> handledParticlesIn) {decayHandlePtr = decayHandlePtrIn; 
+    handledParticles.resize(0); 
+    for(int i = 0; i < int(handledParticlesIn.size()); ++i)
+    handledParticles.push_back( handledParticlesIn[i] ); return true;}  
+
+  // Possibility to pass in pointer for external random number generation.
+  bool setRndmEnginePtr( RndmEngine* rndmEnginePtrIn) 
+    { return rndm.rndmEnginePtr( rndmEnginePtrIn);}  
+
+  // Possibility to pass in pointer for user hooks. 
+  bool setUserHooksPtr( UserHooks* userHooksPtrIn) 
+    { userHooksPtr = userHooksPtrIn; return true;} 
+
+  // Possibility to pass in pointer for beam shape. 
+  bool setBeamShapePtr( BeamShape* beamShapePtrIn) 
+    { beamShapePtr = beamShapePtrIn; return true;} 
+
+  // Possibility to pass in pointer(s) for external cross section.
+  bool setSigmaPtr( SigmaProcess* sigmaPtrIn) 
+    { sigmaPtrs.push_back( sigmaPtrIn); return true;} 
+
+  // Possibility to pass in pointer(s) for external resonance.
+  bool setResonancePtr( ResonanceWidths* resonancePtrIn) 
+    { resonancePtrs.push_back( resonancePtrIn); return true;} 
+
+  // Possibility to pass in pointer for external showers.
+  bool setShowerPtr( TimeShower* timesDecPtrIn, 
+    TimeShower* timesPtrIn = 0, SpaceShower* spacePtrIn = 0) 
+    { timesDecPtr = timesDecPtrIn; timesPtr = timesPtrIn;
+    spacePtr = spacePtrIn; return true;} 
+
+  // Initialize tunes to e+e- and pp/ppbar data.
+  void initTunes(int eeTune = 0, int ppTune = 0);
+
+  // Initialization in the CM frame.
+  bool init( int idAin, int idBin, double eCMin);
+
+  // Initialization with two collinear beams, including fixed target.
+  bool init( int idAin, int idBin, double eAin, double eBin);
+
+  // Initialization with two acollinear beams.
+  bool init( int idAin, int idBin, double pxAin, double pyAin, 
+    double pzAin, double pxBin, double pyBin, double pzBin);
+
+  // Initialization by a Les Houches Event File.
+  bool init( string LesHouchesEventFile, bool skipInit = false);
+
+  // Initialization using the Main beam variables.
+  bool init();
+
+  // Initialization according to the Les Houches Accord.
+  bool init( LHAup* lhaUpPtrIn);
+  // Generate the next event.
+  bool next(); 
+
+  // Generate only the hadronization/decay stage.
+  bool forceHadronLevel();
+
+  // Special routine to allow more decays if on/off switches changed.
+  bool moreDecays() {return hadronLevel.moreDecays(event);}
+
+  // List the current Les Houches event.
+  void LHAeventList(ostream& os = cout) {
+    if (lhaUpPtr > 0) lhaUpPtr->listEvent(os);}
+
+  // Skip a number of Les Houches events at input.
+  bool LHAeventSkip(int nSkip) {
+    if (lhaUpPtr > 0) return lhaUpPtr->skipEvent(nSkip); return false;}
+
+  // Main routine to provide final statistics on generation.
+  void statistics(bool all = false, bool reset = false);
+
+  // Read in settings values: shorthand, not new functionality.
+  bool   flag(string key) {return settings.flag(key);}
+  int    mode(string key) {return settings.mode(key);} 
+  double parm(string key) {return settings.parm(key);}
+  string word(string key) {return settings.word(key);}
+
+  // The event record for the parton-level central process.
+  Event          process;
+
+  // The event record for the complete event history.
+  Event          event;
+
+  // Information on the generation: current subprocess and error statistics.
+  Info           info;
+
+  // Settings: databases of flags/modes/parms/words to control run.
+  Settings       settings;
+
+  // ParticleData: the particle data table/database.
+  ParticleData   particleData;
+
+  // Random number generator.
+  Rndm           rndm;
+
+  // Standard Model couplings, including alphaS and alphaEM.
+  CoupSM         coupSM;
+
+  // SusyLesHouches - SLHA object for interface to SUSY spectra.
+  SusyLesHouches slha;
+
+  // The partonic content of each subcollision system (auxiliary to event).
+  PartonSystems  partonSystems; 
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int NTRY, SUBRUNDEFAULT;
+
+  // Initialization data, extracted from database.
+  string xmlPath;
+  bool   doProcessLevel, doPartonLevel, doHadronLevel, checkEvent, 
+         doDiffraction;
+  int    nErrList;
+  double epTolErr, epTolWarn;
+
+  // Initialization data, extracted from init(...) call.
+  bool   isConstructed, isInit;
+  int    idA, idB, frameType;  
+  double mA, mB, pxA, pxB, pyA, pyB, pzA, pzB, eA, eB, 
+         pzAcm, pzBcm, eCM, betaZ, gammaZ;
+  Vec4   pAinit, pBinit, pAnow, pBnow;
+  RotBstMatrix MfromCM, MtoCM;
+
+  // information for error checkout.
+  int    nErrEvent;
+  vector<int> iErrId, iErrCol, iErrNan, iErrNanVtx;
+
+  // Pointers to the parton distributions of the two incoming beams.
+  PDF* pdfAPtr;  
+  PDF* pdfBPtr; 
+
+  // Extra PDF pointers to be used in hard processes only. 
+  PDF* pdfHardAPtr;  
+  PDF* pdfHardBPtr; 
+
+  // Extra Pomeron PDF pointers to be used in diffractive processes only. 
+  PDF* pdfPomAPtr;  
+  PDF* pdfPomBPtr; 
+
+  // Keep track when "new" has been used and needs a "delete" for PDF's.  
+  bool useNewPdfA, useNewPdfB, useNewPdfHard, useNewPdfPomA, useNewPdfPomB;
+
+  // The two incoming beams.
+  BeamParticle beamA;
+  BeamParticle beamB;
+
+  // Alternative Pomeron beam-inside-beam.
+  BeamParticle beamPomA;
+  BeamParticle beamPomB;
+
+  // LHAup object for generating external events.
+  bool   doLHA, useNewLHA;
+  LHAup* lhaUpPtr;
+
+  // Pointer to external decay handler and list of particles it handles.
+  DecayHandler* decayHandlePtr;
+  vector<int>   handledParticles;
+
+  // Pointer to UserHooks object for user interaction with program.
+  UserHooks* userHooksPtr;
+  bool       hasUserHooks, doVetoProcess, doVetoPartons;
+
+  // Pointer to BeamShape object for beam momentum and interaction vertex.
+  BeamShape* beamShapePtr;
+  bool       useNewBeamShape, doMomentumSpread, doVertexSpread;
+
+  // Pointers to external processes derived from the Pythia base classes.
+  vector<SigmaProcess*> sigmaPtrs;  
+
+  // Pointers to external calculation of resonance widths.
+  vector<ResonanceWidths*> resonancePtrs;
+
+  // Pointers to timelike and spacelike showers.
+  TimeShower*  timesDecPtr;
+  TimeShower*  timesPtr;
+  SpaceShower* spacePtr;
+  bool         useNewTimes, useNewSpace;
+
+  // The main generator class to define the core process of the event.
+  ProcessLevel processLevel;
+
+  // The main generator class to produce the parton level of the event.
+  PartonLevel partonLevel;
+
+  // The main generator class to produce the hadron level of the event.
+  HadronLevel hadronLevel;
+
+  // The total cross section class is used both on process and parton level.
+  SigmaTotal sigmaTot; 
+
+  // Write the Pythia banner, with symbol and version information.
+  void banner(ostream& os = cout);
+
+  // Check for lines in file that mark the beginning of new subrun.
+  int readSubrun(string line, bool warn = true, ostream& os = cout);
+
+  // Initialization routine to set up the whole generation machinery.
+  bool initInternal();
+
+  // Check that combinations of settings are allowed; change if not.
+  void checkSettings();
+
+  // Check that beams and beam combination can be handled.
+  bool checkBeams();
+
+  // Calculate kinematics at initialization.
+  bool initKinematics();
+
+  // Set up pointers to PDFs.
+  bool initPDFs();
+
+  // Recalculate kinematics for each event when beam momentum has a spread.
+  void nextKinematics();
+
+  // Boost from CM frame to lab frame, or inverse. Set production vertex.
+  void boostAndVertex(bool toLab, bool setVertex);
+
+  // Check that the final event makes sense.
+  bool check(ostream& os = cout);
+
+  // Auxiliary to set parton densities among list of possibilities.
+  PDF* getPDFPtr(int idIn, int sequence = 1);
+
+};
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_Pythia_H
diff --git a/PYTHIA8/pythia8140/include/PythiaComplex.h b/PYTHIA8/pythia8140/include/PythiaComplex.h
new file mode 100644 (file)
index 0000000..22703cb
--- /dev/null
@@ -0,0 +1,21 @@
+// PythiaComplex.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for typedef'd double precision complex numbers.
+
+#ifndef Pythia8_PythiaComplex_H
+#define Pythia8_PythiaComplex_H
+
+// Stdlib header for complex numbers.
+# include <complex>
+
+namespace Pythia8 {
+
+// Convenient typedef for double precision complex numbers.
+typedef std::complex<double> complex;
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PythiaComplex_H
diff --git a/PYTHIA8/pythia8140/include/PythiaStdlib.h b/PYTHIA8/pythia8140/include/PythiaStdlib.h
new file mode 100644 (file)
index 0000000..b25db6a
--- /dev/null
@@ -0,0 +1,88 @@
+// PythiaStdlib.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for functionality pulled in from Stdlib,
+// plus a few useful utilities (small powers; positive square root,
+// Gamma function).
+
+#ifndef Pythia8_PythiaStdlib_H
+#define Pythia8_PythiaStdlib_H
+
+// Stdlib header files for mathematics.
+#include <cmath>
+#include <cstdlib>
+
+// Stdlib header files for strings and containers.
+#include <string>
+#include <vector>
+#include <map>
+#include <deque>
+
+// Stdlib header file for input and output.
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <sstream>
+
+// Define pi if not yet done.
+#ifndef M_PI
+#define M_PI 3.1415926535897932385
+#endif
+
+// By this declaration you do not need to use std:: qualifier everywhere.
+using namespace std;
+
+// Alternatively you can specify exactly which std:: methods will be used.
+/*
+namespace Pythia8 {
+// Generic utilities and mathematical functions.
+using std::swap;
+using std::max;
+using std::min; 
+using std::abs; 
+// Strings and containers.
+using std::string; 
+using std::vector; 
+using std::map; 
+using std::deque; 
+// Input/output streams.
+using std::cin; 
+using std::cout; 
+using std::cerr; 
+using std::istream; 
+using std::ostream; 
+using std::ifstream; 
+using std::ofstream; 
+using std::istringstream; 
+using std::ostringstream; 
+// Input/output formatting.
+using std::endl; 
+using std::fixed; 
+using std::scientific; 
+using std::left; 
+using std::right; 
+using std::setw; 
+using std::setprecision; 
+} // end namespace Pythia8
+*/
+
+namespace Pythia8 {
+
+// Powers of small integers - for balance speed/code clarity.
+inline double pow2(const double& x) {return x*x;}
+inline double pow3(const double& x) {return x*x*x;}
+inline double pow4(const double& x) {return x*x*x*x;}
+inline double pow5(const double& x) {return x*x*x*x*x;}
+inline double pow6(const double& x) {return x*x*x*x*x*x;}
+
+// Avoid problem with negative square root argument (from roundoff).
+inline double sqrtpos(const double& x) {return sqrt( max( 0., x));}
+
+// The Gamma function for real argument.
+double GammaReal(double x);
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PythiaStdlib_H
diff --git a/PYTHIA8/pythia8140/include/ResonanceDecays.h b/PYTHIA8/pythia8140/include/ResonanceDecays.h
new file mode 100644 (file)
index 0000000..8a9a65d
--- /dev/null
@@ -0,0 +1,80 @@
+// ResonanceDecays.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This file contains the main class for performing resonance decays.
+// ResonanceDecays: handles the sequential decay of resonances in process.
+
+#ifndef Pythia8_ResonanceDecays_H
+#define Pythia8_ResonanceDecays_H
+
+#include "Basics.h"
+#include "Event.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "ResonanceWidths.h"
+#include "Settings.h"
+
+namespace Pythia8 {
+  
+//==========================================================================
+
+// The ResonanceDecays class handles the sequential decay of resonances
+// that are part of the hard process (t, W, Z, H, SUSY,...).
+
+class ResonanceDecays {
+
+public:
+
+  // Constructor. 
+  ResonanceDecays() {} 
+
+  // Store pointers to Info and Rndm for error messages and random numbers.
+  void init(Info* infoPtrIn,  ParticleData* particleDataPtrIn, 
+    Rndm* rndmPtrIn) {infoPtr = infoPtrIn; 
+    particleDataPtr = particleDataPtrIn; rndmPtr = rndmPtrIn;}
+  // Generate the next decay sequence.
+  bool next( Event& process); 
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int    NTRYCHANNEL, NTRYMASSES;
+  static const double MSAFETY, WIDTHCUT, TINY, TINYBWRANGE,
+                      WTCORRECTION[11];
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to the random number generator.
+  Rndm*         rndmPtr;
+
+  // Select masses of decay products.
+  bool pickMasses(); 
+
+  // Select colours of decay products.
+  bool pickColours(int iDec, Event& process);
+
+  // Select kinematics isotropic in phase space.
+  bool pickKinematics();
+
+  // Flavour, colour and momentum information.
+  int            id0, mult;
+  double         m0;
+  vector<int>    idProd, cols, acols;
+  vector<double> mProd;
+  vector<Vec4>   pProd;
+
+};
+
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ResonanceDecays_H
diff --git a/PYTHIA8/pythia8140/include/ResonanceWidths.h b/PYTHIA8/pythia8140/include/ResonanceWidths.h
new file mode 100644 (file)
index 0000000..bb423c4
--- /dev/null
@@ -0,0 +1,670 @@
+// ResonanceWidths.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for resonance properties: dynamical widths etc. 
+// ResonanceWidths: base class for all resonances.
+// ResonanceGmZ, ...: derived classes for individual resonances.
+
+#ifndef Pythia8_ResonanceWidths_H
+#define Pythia8_ResonanceWidths_H
+
+#include "Basics.h"
+#include "Info.h"
+#include "ParticleData.h"
+#include "PythiaStdlib.h"
+#include "Settings.h"
+#include "StandardModel.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Forward references to ParticleData and StandardModel classes.
+class DecayChannel;
+class ParticleData;
+class ParticleDataEntry;
+class CoupSM;
+  
+//==========================================================================
+
+// The ResonanceWidths is the base class. Also used for generic resonaces.
+
+class ResonanceWidths {
+
+public: 
+
+  // Destructor.
+  virtual ~ResonanceWidths() {}
+
+  // Set up standard properties.
+  void initBasic(int idResIn, bool isGenericIn = false) {
+    idRes = idResIn; isGeneric = isGenericIn;}
+  // Calculate and store partial and total widths at the nominal mass. 
+  bool init(Info* infoPtrIn, Settings* settingsPtrIn,
+    ParticleData* particleDataPtrIn, CoupSM* coupSMPtrIn);
+
+  // Return identity of particle species.
+  int id() const {return idRes;}
+  // Calculate the total/open width for given mass, charge and instate.
+  double width(int idSgn, double mHatIn, int idInFlavIn = 0,  
+    bool openOnly = false, bool setBR = false, int idOutFlav1 = 0, 
+    int idOutFlav2 = 0); 
+
+  // Special case to calculate open final-state width.
+  double widthOpen(int idSgn, double mHatIn, int idIn = 0) {
+    return width( idSgn, mHatIn, idIn, true, false);}  
+
+  // Special case to store open final-state widths for channel selection.
+  double widthStore(int idSgn, double mHatIn, int idIn = 0) {
+    return width( idSgn, mHatIn, idIn, true, true);}  
+
+  // Return fraction of width open for particle and antiparticle.
+  double openFrac(int idSgn) {return (idSgn > 0) ? openPos : openNeg;}
+
+  // Return forced rescaling factor of resonance width.
+  double widthRescaleFactor() {return forceFactor;} 
+
+  // Special case to calculate one final-state width.
+  // Currently only used for Higgs -> qqbar, g g or gamma gamma. 
+  double widthChan(double mHatIn, int idOutFlav1, int idOutFlav2) {
+    return width( 1, mHatIn, 0, false, false, idOutFlav1, idOutFlav2);}  
+
+protected:
+
+  // Constructor.
+  ResonanceWidths() {}
+
+  // Constants: could only be changed in the code itself.
+  static const int    NPOINT;
+  static const double MASSMARGIN;
+
+  // Particle properties always present.
+  int    idRes, hasAntiRes;
+  bool   doForceWidth, isGeneric;
+  double minWidth, minThreshold, mRes, GammaRes, m2Res, GamMRat, 
+         openPos, openNeg, forceFactor;
+
+  // Properties for currently studied decay channel(s).
+  int    iChannel, onMode, meMode, mult, id1, id2, id3, id1Abs, 
+         id2Abs, id3Abs, idInFlav;
+  double widNow, mHat, mf1, mf2, mf3, mr1, mr2, mr3, ps, kinFac,
+         alpEM, alpS, colQ, preFac; 
+
+  // Pointer to properties of the particle species.
+  ParticleDataEntry* particlePtr;
+
+  // Pointer to various information on the generation.
+  Info*         infoPtr;
+
+  // Pointer to the settings database.
+  Settings*     settingsPtr;
+
+  // Pointer to the particle data table.
+  ParticleData* particleDataPtr;
+
+  // Pointer to Standard Model couplings.
+  CoupSM*       coupSMPtr;
+  // Initialize constants.
+  virtual void initConstants() {} 
+  // Calculate various common prefactors for the current mass.
+  // Optional argument calledFromInit only used for Z0.
+  virtual void calcPreFac(bool = false) {}
+
+  // Calculate width for currently considered channel.
+  // Optional argument calledFromInit only used for Z0.
+  virtual void calcWidth(bool = false) {}
+
+  // Simple routines for matrix-element integration over Breit-Wigners.
+  double numInt1BW(double mHatIn, double m1, double Gamma1, double mMin1, 
+    double m2, int psMode = 1);
+  double numInt2BW(double mHatIn, double m1, double Gamma1, double mMin1, 
+    double m2, double Gamma2, double mMin2, int psMode = 1);
+
+};
+  
+//==========================================================================
+
+// The ResonanceGeneric class handles a generic resonance.
+// Only needs a constructor; for the rest uses defaults in base class. 
+
+class ResonanceGeneric : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceGeneric(int idResIn) {initBasic(idResIn, true);} 
+
+};
+  
+//==========================================================================
+
+// The ResonanceGmZ class handles the gamma*/Z0 resonance.
+
+class ResonanceGmZ : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceGmZ(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  int    gmZmode;
+  double thetaWRat, ei2, eivi, vi2ai2, gamNorm, intNorm, resNorm;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool calledFromInit = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceW class handles the W+- resonance.
+
+class ResonanceW : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceW(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat, alpEM;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceTop class handles the top/antitop resonance.
+
+class ResonanceTop : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceTop(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat, m2W;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceFour class handles fourth-generation resonances.
+
+class ResonanceFour : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceFour(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat, m2W;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceH class handles the SM and BSM Higgs resonance.
+// higgsType = 0 : SM H; = 1: h^0/H_1; = 2 : H^0/H_2; = 3 : A^0/A_3.
+
+class ResonanceH : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceH(int higgsTypeIn, int idResIn) : higgsType(higgsTypeIn)
+    {initBasic(idResIn);} 
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const double MASSMIN, GAMMAMARGIN;
+
+  // Higgs type in current instance.
+  int    higgsType;
+
+  // Locally stored properties and couplings.
+  bool   useCubicWidth, useRunLoopMass; 
+  double sin2tW, cos2tW, mT, mZ, mW, mHchg, GammaT, GammaZ, GammaW,
+         coup2d, coup2u, coup2l, coup2Z, coup2W, coup2Hchg, coup2H1H1, 
+         coup2A3A3, coup2H1Z, coup2A3Z, coup2A3H1, coup2HchgW,
+         kinFacT[101], kinFacZ[101], kinFacW[101];
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+  // Sum up loop contributions in Higgs -> g + g.
+  double eta2gg();
+
+  // Sum up loop contributions in Higgs -> gamma + gamma.
+  double eta2gaga();
+
+  // Sum up loop contributions in Higgs -> gamma + Z0.
+  double eta2gaZ();
+
+};
+  
+//==========================================================================
+
+// The ResonanceHchg class handles the H+- resonance.
+
+class ResonanceHchg : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceHchg(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  bool   useCubicWidth; 
+  double thetaWRat, mW, tanBeta, tan2Beta, coup2H1W;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceZprime class handles the gamma*/Z0 /Z'^0 resonance.
+
+class ResonanceZprime : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceZprime(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  int    gmZmode;
+  double sin2tW, cos2tW, thetaWRat, mZ, GammaZ, m2Z, GamMRatZ, afZp[20], 
+         vfZp[20], coupZpWW, ei2, eivi, vai2, eivpi, vaivapi, vapi2,
+         gamNorm, gamZNorm, ZNorm, gamZpNorm, ZZpNorm, ZpNorm;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool calledFromInit = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceWprime class handles the W'+- resonance.
+
+class ResonanceWprime : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceWprime(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat, cos2tW, alpEM, aqWp, vqWp, alWp, vlWp, coupWpWZ;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceRhorizontal class handles the R^0 resonance.
+
+class ResonanceRhorizontal : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceRhorizontal(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+   
+//==========================================================================
+
+// The ResonanceExcited class handles excited-fermion resonances.
+
+class ResonanceExcited : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceExcited(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double Lambda, coupF, coupFprime, coupFcol, sin2tW, cos2tW;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceGraviton class handles the excited Graviton resonance.
+
+class ResonanceGraviton : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceGraviton(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  bool   m_smbulk;
+  double kappaMG;
+  // Couplings between graviton and SM (map from particle id to coupling).
+  double m_coupling[26];
+
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+
+//==========================================================================
+
+// The ResonanceKKgluon class handles the excited kk-gluon resonance.
+
+class ResonanceKKgluon : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceKKgluon(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  bool   m_smbulk;
+
+  // Couplings between KK gluon and SM (map from particle id to coupling).
+  double m_coupling[10];
+
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+
+
+//==========================================================================
+
+// The ResonanceLeptoquark class handles the LQ/LQbar resonance.
+
+class ResonanceLeptoquark : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceLeptoquark(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double kCoup;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+
+//==========================================================================
+
+// The ResonanceNuRight class handles righthanded Majorana neutrinos.
+
+class ResonanceNuRight : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceNuRight(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat, mWR;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceZRight class handles the Z_R^0 resonance.
+
+class ResonanceZRight : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceZRight(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double sin2tW, thetaWRat;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceWRight class handles the W_R+- resonance.
+
+class ResonanceWRight : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceWRight(int idResIn) {initBasic(idResIn);} 
+  
+private: 
+
+  // Locally stored properties and couplings.
+  double thetaWRat;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+// The ResonanceHchgchgLeft class handles the H++/H-- (left) resonance.
+
+class ResonanceHchgchgLeft : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceHchgchgLeft(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  double yukawa[4][4], gL, vL, mW;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+   
+//==========================================================================
+
+// The ResonanceHchgchgRight class handles the H++/H-- (right) resonance.
+
+class ResonanceHchgchgRight : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceHchgchgRight(int idResIn) {initBasic(idResIn);} 
+private: 
+
+  // Locally stored properties and couplings.
+  int    idWR;
+  double yukawa[4][4], gR;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  virtual void calcPreFac(bool = false);
+
+  // Caclulate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+  
+//==========================================================================
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ResonanceWidths_H
diff --git a/PYTHIA8/pythia8140/include/Settings.h b/PYTHIA8/pythia8140/include/Settings.h
new file mode 100644 (file)
index 0000000..3587d4a
--- /dev/null
@@ -0,0 +1,234 @@
+// Settings.h is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Header file for the settings database.
+// Flag: helper class with bool flags.
+// Mode: helper class with int modes.
+// Parm: (short for parameter) helper class with double parameters.
+// Word: helper class with string words.
+// Settings: maps of flags, modes, parms and words with input/output.
+
+#ifndef Pythia8_Settings_H
+#define Pythia8_Settings_H
+
+#include "Info.h"
+#include "PythiaStdlib.h"
+
+namespace Pythia8 {
+
+//==========================================================================
+
+// Class for bool flags.
+
+class Flag {
+
+public:
+
+  // Constructor
+  Flag(string nameIn = " ", bool defaultIn = false) : name(nameIn), 
+    valNow(defaultIn) , valDefault(defaultIn) { }
+
+  // Data members.
+  string name;
+  bool   valNow, valDefault;
+
+};
+
+//==========================================================================
+
+// Class for integer modes.
+
+class Mode {
+
+public:
+
+  // Constructor
+  Mode(string nameIn = " ", int defaultIn = 0, bool hasMinIn = false,
+