pythia8130 distributed with AliRoot
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Oct 2009 12:45:36 +0000 (12:45 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Oct 2009 12:45:36 +0000 (12:45 +0000)
163 files changed:
PYTHIA8/libpythia8.pkg [new file with mode: 0644]
PYTHIA8/pythia8130/include/Analysis.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Basics.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/BeamParticle.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/BeamRemnants.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/BeamShape.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/BoseEinstein.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Event.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/FragmentationFlavZpT.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/FragmentationSystems.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/HadronLevel.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/HepMCInterface.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Info.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/LHAFortran.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/LHAPDFInterface.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/LesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/MiniStringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/MultipleInteractions.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ParticleData.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ParticleDecays.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/PartonDistributions.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/PartonLevel.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/PhaseSpace.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ProcessContainer.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ProcessLevel.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Pythia.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Pythia6Interface.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/PythiaComplex.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/PythiaStdlib.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ResonanceDecays.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/ResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/Settings.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaCompositeness.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaEW.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaExtraDim.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaHiggs.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaLeftRightSym.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaLeptoquark.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaNewGaugeBosons.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaOnia.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaProcess.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaQCD.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaSUSY.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SigmaTotal.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SpaceShower.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/StandardModel.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/StringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/SusyLesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/TimeShower.h [new file with mode: 0644]
PYTHIA8/pythia8130/include/UserHooks.h [new file with mode: 0644]
PYTHIA8/pythia8130/src/Analysis.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/Basics.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/BeamParticle.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/BeamRemnants.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/BeamShape.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/BoseEinstein.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/Event.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/FragmentationFlavZpT.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/FragmentationSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/HadronLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/Info.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/LesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/MiniStringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/MultipleInteractions.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ParticleData.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ParticleDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/PartonDistributions.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/PartonLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/PhaseSpace.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ProcessContainer.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ProcessLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/Pythia.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ResonanceDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/ResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/Settings.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaCompositeness.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaEW.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaExtraDim.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaHiggs.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaLeftRightSym.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaLeptoquark.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaNewGaugeBosons.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaOnia.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaProcess.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaQCD.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaSUSY.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SigmaTotal.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SpaceShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/StandardModel.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/StringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/SusyLesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/TimeShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/src/UserHooks.cxx [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ASecondHardProcess.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/AccessPYTHIA6Processes.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/BeamParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/BeamRemnants.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/BeamShape.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Bibliography.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/BoseEinsteinEffects.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/CompositenessProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/CouplingsAndScales.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ElectroweakProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ErrorChecks.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/EventAnalysis.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/EventInformation.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/EventRecord.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/EventStatistics.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ExternalDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ExtraDimensionalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/FlavourSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/FourVectors.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/FourthGenerationProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Fragmentation.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Frontpage.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Glossary.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/HadronLevelStandalone.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/HepMCInterface.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/HiggsProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Histograms.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ImplementNewShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Index.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/LeftRightSymmetryProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/LeptoquarkProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/LesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/MainProgramSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/MasterSwitches.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/MultipleInteractions.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/NewGaugeBosonProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/OniaProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/PDFSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/PYTHIA6TranslationTable.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ParticleData.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ParticleDataScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ParticleDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ParticleProperties.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/PartonDistributions.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/PhaseSpaceCuts.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ProcessSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ProgramFiles.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ProgramFlow.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/QCDProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/RandomNumberSeed.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/RandomNumbers.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/RandomNumbersAndChecks.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/ResonanceDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SUSYLesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SUSYProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SampleMainPrograms.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SaveSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SemiInternalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SemiInternalResonances.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SettingsScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/SpacelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/StandardModelParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/TimelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/TopProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/TotalCrossSections.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Tunes.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/UpdateHistory.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/UserHooks.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Version.xml [new file with mode: 0644]
PYTHIA8/pythia8130/xmldoc/Welcome.xml [new file with mode: 0644]

diff --git a/PYTHIA8/libpythia8.pkg b/PYTHIA8/libpythia8.pkg
new file mode 100644 (file)
index 0000000..aba88f2
--- /dev/null
@@ -0,0 +1,51 @@
+#-*- 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
+
+EINCLUDE:= PYTHIA8/pythia8130/include
+ifeq (macosxicc,$(ALICE_TARGET))
+PACKFFLAGS      := $(filter-out -O%,$(FFLAGS))
+endif
diff --git a/PYTHIA8/pythia8130/include/Analysis.h b/PYTHIA8/pythia8130/include/Analysis.h
new file mode 100644 (file)
index 0000000..99373ef
--- /dev/null
@@ -0,0 +1,343 @@
+// Analysis.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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);
+
+  // 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);
+
+  // 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; 
+    piMass = ParticleDataTable::m0(211);
+  }
+      
+  // 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 j) const {return jets[j].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);
+
+  // 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 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;
+
+};  
+
+//**************************************************************************
+
+// 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.) : etaMax(etaMaxIn), 
+    nEta(nEtaIn), nPhi(nPhiIn), select(selectIn), smear(smearIn),
+    resolution(resolutionIn), upperCut(upperCutIn), 
+    threshold(thresholdIn), nFew(0) { }
+  
+  // 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;}
+  double 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);
+
+  // 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;
+
+};  
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // end Pythia8_Analysis_H
+
diff --git a/PYTHIA8/pythia8130/include/Basics.h b/PYTHIA8/pythia8130/include/Basics.h
new file mode 100644 (file)
index 0000000..fecf13c
--- /dev/null
@@ -0,0 +1,381 @@
+// Basics.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 (static member functions).
+// 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() {} 
+  Rndm(int seedIn) { init(seedIn);} 
+
+  // Possibility to pass in pointer for external random number generation.
+  static bool rndmEnginePtr( RndmEngine* rndmPtrIn);  
+
+  // Initialize, normally at construction or in first call.
+  static void init(int seedIn = 0) ;
+
+  // Generate next random number uniformly between 0 and 1.
+  static double flat() ;
+
+  // Generate random numbers according to exp(-x).
+  static double exp() { return -log(flat()) ;} 
+
+  // Generate random numbers according to x * exp(-x).
+  static double xexp() { return -log(flat() * flat()) ;} 
+
+  // Generate random numbers according to exp(-x^2/2).
+  static double gauss() ;
+
+  // Pick one option among  vector of (positive) probabilities.
+  static int pick(const vector<double>& prob) ; 
+
+private:
+
+  // State of the random number generator.
+  static bool   initRndm, saveGauss; 
+  static int    i97, j97, defaultSeed;
+  static double u[97], c, cd, cm, save;
+
+  // Pointer for external random number generation.
+  static bool   useExternalRndm; 
+  static RndmEngine* rndmPtr;
+
+};
+
+//**************************************************************************
+
+// 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 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 pPlus() const {return tt + zz;}
+  double pMinus() 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-() {xx = -xx; yy = -yy; zz = -zz; tt = -tt; return *this;}
+  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.) ;
+
+  // Return content of specific bin: -1 gives underflow and nBin overflow.
+  double getBinContent(int iBin) ;
+
+  // Return number of entries
+  double getEntries() {return nFill; }
+
+  // Print histogram contents as a table (e.g. for Gnuplot).
+  void table(ostream& os = cout) const ;
+
+  // 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);
+
+  // Print a histogram with overloaded << operator.
+  friend ostream& operator<<(ostream& os, const Hist& h) ;
+
+private:
+
+  // Constants: could only be changed in the code itself.
+  static const int    NBINMAX, 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/pythia8130/include/BeamParticle.h b/PYTHIA8/pythia8130/include/BeamParticle.h
new file mode 100644 (file)
index 0000000..ec6e4a7
--- /dev/null
@@ -0,0 +1,284 @@
+// BeamParticle.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+
+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.), 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;}  
+
+  // 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);}
+  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*mRes + pRes.pT2();}
+  int col() const {return colRes;}
+  int acol() const {return acolRes;}
+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;
+  // 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() {Q2ValFracSav = -1.;}  
+
+  // Initialize data on a beam particle and save pointers.
+  void init( int idIn, double pzIn, double eIn, double mIn, 
+    Info* infoPtrIn, PDF* pdfInPtr, PDF* pdfHardInPtr, 
+    bool isUnresolvedIn, StringFlav* flavSelPtrIn);
+
+  // 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);}
+
+  // 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); 
+
+  // 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;
+  // Pinters 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/pythia8130/include/BeamRemnants.h b/PYTHIA8/pythia8130/include/BeamRemnants.h
new file mode 100644 (file)
index 0000000..9770c98
--- /dev/null
@@ -0,0 +1,83 @@
+// BeamRemnants.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "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, BeamParticle* beamAPtrIn, 
+    BeamParticle* 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 int    NTRYCOLMATCH, NTRYKINMATCH;
+
+  // Initialization data, read from Settings.
+  bool   doPrimordialKT, 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;
+
+  // Pointers to the two incoming beams.
+  BeamParticle* beamAPtr;
+  BeamParticle* beamBPtr;
+
+  // 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/pythia8130/include/BeamShape.h b/PYTHIA8/pythia8130/include/BeamShape.h
new file mode 100644 (file)
index 0000000..337f13a
--- /dev/null
@@ -0,0 +1,61 @@
+// BeamShape.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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();
+
+  // 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;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_BeamShape_H
diff --git a/PYTHIA8/pythia8130/include/BoseEinstein.h b/PYTHIA8/pythia8130/include/BoseEinstein.h
new file mode 100644 (file)
index 0000000..aedd028
--- /dev/null
@@ -0,0 +1,92 @@
+// Bose-Einstein.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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);
+
+  // 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/pythia8130/include/Event.h b/PYTHIA8/pythia8130/include/Event.h
new file mode 100644 (file)
index 0000000..88918fa
--- /dev/null
@@ -0,0 +1,542 @@
+// Event.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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"
+#include "Settings.h"
+
+namespace Pythia8 {
+
+//**************************************************************************
+
+// Forward references to ParticleData 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.), 
+    particlePtr(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.) 
+    {setParticlePtr();}  
+  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.) {setParticlePtr();}  
+  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), 
+    particlePtr(pt.particlePtr) { } 
+  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; particlePtr = pt.particlePtr; } return *this; } 
+      
+  // Member functions for input.
+  void id(int idIn) {idSave = idIn; setParticlePtr();}
+  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);}
+
+  // Member functions for output; derived double quantities.
+  double m2()        const {return mSave*mSave;}
+  double mCalc()     const {return pSave.mCalc();}
+  double m2Calc()    const {return pSave.m2Calc();}
+  double eCalc()     const {return sqrt(mSave*mSave + pSave.pAbs2());}
+  double pT()        const {return pSave.pT();}
+  double pT2()       const {return pSave.pT2();}
+  double mT()        const {return sqrt(mSave*mSave + pSave.pT2());}
+  double mT2()       const {return mSave*mSave + pSave.pT2();}
+  double pAbs()      const {return pSave.pAbs();}
+  double pAbs2()     const {return pSave.pAbs2();}
+  double theta()     const {return pSave.theta();}
+  double phi()       const {return pSave.phi();}
+  double thetaXZ()   const {return pSave.thetaXZ();}
+  double pPlus()     const {return pSave.pPlus();}
+  double pMinus()    const {return pSave.pMinus();}
+  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 particlePtr->name(idSave);}
+  string nameWithStatus(int maxLen = 20) const;
+  int    spinType()  const {return particlePtr->spinType();}
+  int    chargeType() const {return particlePtr->chargeType(idSave);}
+  double charge()    const {return  particlePtr->charge(idSave);}
+  bool   isCharged() const {return (particlePtr->chargeType(idSave) != 0);}
+  bool   isNeutral() const {return (particlePtr->chargeType(idSave) == 0);}
+  int    colType()   const {return particlePtr->colType(idSave);}
+  double m0()        const {return particlePtr->m0();}
+  double mWidth()    const {return particlePtr->mWidth();}
+  double mMin()      const {return particlePtr->mMin();}
+  double mMax()      const {return particlePtr->mMax();}
+  double mass()      const {return particlePtr->mass();}
+  double constituentMass() const {return particlePtr->constituentMass();}
+  double tau0()      const {return particlePtr->tau0();}
+  bool   mayDecay()  const {return particlePtr->mayDecay();}
+  bool   canDecay()  const {return particlePtr->canDecay();}
+  bool   doExternalDecay() const {return particlePtr->doExternalDecay();}
+  bool   isResonance() const {return particlePtr->isResonance();}
+  bool   isVisible() const {return particlePtr->isVisible();}
+  bool   isLepton()  const {return particlePtr->isLepton();}
+  bool   isQuark()   const {return particlePtr->isQuark();}
+  bool   isGluon()   const {return particlePtr->isGluon();}
+  bool   isHadron()  const {return particlePtr->isHadron();}
+  ParticleDataEntry& particleData() const {return *particlePtr;}
+
+  // 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); 
+
+  // Member function to set the ParticleDataEntry pointer, using idSave.
+  void setParticlePtr();
+
+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* particlePtr;  //!
+
+};
+
+// 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 juction 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 = "----------------------------------------";}
+  Event& operator=(const Event& oldEvent);
+
+  // Initialize colour and header specification for event listing.
+  void init( string headerIn = "");
+
+  // Clear event record.
+  void clear() {entry.resize(0); maxColTag = startColTag; 
+    clearJunctions(); clearSystems();}
+
+  // 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); 
+    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) ); 
+    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) ); 
+    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.) ); 
+    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.) ); 
+    if (col > maxColTag) maxColTag = col;   
+    if (acol > maxColTag) maxColTag = acol;
+    return entry.size() - 1;
+  }
+
+  // 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(ostream& os = cout) {list(false, false, os);}  
+  void list(bool showScaleAndVertex, bool showMothersAndDaughters = false, 
+    ostream& os = cout);  
+
+  // 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) entry[i].setParticlePtr(); } 
+
+  // 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;
+  // 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;
+
+  // Operations with grouped systems of partons for internal use only.
+  // (Used by combined MI, ISR, FSR and BR machinery in PartonLevel.)
+
+  // Reset all systems and system number to empty.
+  void clearSystems() {beginSys.resize(0); sizeSys.resize(0); 
+    memberSys.resize(0);}
+  
+  // Get number of systems or number of members in a system. 
+  int sizeSystems() const {return beginSys.size();}
+  int sizeSystem(int iSys) const {return sizeSys[iSys];}
+
+  // New system or new parton in system.
+  int newSystem() {beginSys.push_back(memberSys.size()); 
+    sizeSys.push_back(0); return (beginSys.size() - 1);}
+  void addToSystem(int iSys, int iPos);
+
+  // Get or set value of given member in given system. Replace value by new.
+  int getInSystem(int iSys, int iMem) const {
+    return memberSys[beginSys[iSys] + iMem];}
+  void setInSystem(int iSys, int iMem, int iPos) {
+    memberSys[beginSys[iSys] + iMem] = iPos;}
+  void replaceInSystem(int iSys, int iPosOld, int iPosNew);
+
+  // List members in systems; for debug mainly.
+  void listSystems(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;
+
+  // Offsets, sizes and values of systems.
+  vector<int> beginSys, sizeSys, memberSys;
+  
+};
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // end Pythia8_Event_H
diff --git a/PYTHIA8/pythia8130/include/FragmentationFlavZpT.h b/PYTHIA8/pythia8130/include/FragmentationFlavZpT.h
new file mode 100644 (file)
index 0000000..bc7f020
--- /dev/null
@@ -0,0 +1,173 @@
+// FragmentationFlavZpT.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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();
+
+  // Pick a light d, u or s quark according to fixed ratios.
+  int pickLightQ() { double rndmFlav = probQandS * Rndm::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;
+};
+//**************************************************************************
+
+// The StringZ class is used to sample the fragmentation function f(z).
+
+class StringZ {
+
+public:
+
+  // Constructor. 
+  StringZ() {}
+
+  // Initialize data members.
+  void init();
+  
+  // 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);
+
+};
+//**************************************************************************
+
+// The StringPT class is used to select select transverse momenta.
+
+class StringPT {
+
+public:
+
+  // Constructor. 
+  StringPT() {}
+
+  // Initialize data members.
+  void init();
+
+  // Return px and py separately, but really same routine.
+  double px() {return pxy();}
+  double py() {return pxy();}
+
+private: 
+
+  // Initialization data, to be read from Settings.
+  double sigmaQ, enhancedFraction, enhancedWidth;
+
+  // pT fragmentation spectrum.
+  double pxy();
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_FragmentationFlavZpT_H
diff --git a/PYTHIA8/pythia8130/include/FragmentationSystems.h b/PYTHIA8/pythia8130/include/FragmentationSystems.h
new file mode 100644 (file)
index 0000000..7399ee6
--- /dev/null
@@ -0,0 +1,183 @@
+// FragmentationSystems.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "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() {}
+
+  // Initialize and save pointers.
+  void init(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.
+  void 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);
+
+private:
+
+  // 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/pythia8130/include/HadronLevel.h b/PYTHIA8/pythia8130/include/HadronLevel.h
new file mode 100644 (file)
index 0000000..de8b641
--- /dev/null
@@ -0,0 +1,112 @@
+// HadronLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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, 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;
+
+  // 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/pythia8130/include/HepMCInterface.h b/PYTHIA8/pythia8130/include/HepMCInterface.h
new file mode 100644 (file)
index 0000000..97b7ab8
--- /dev/null
@@ -0,0 +1,103 @@
+// HepMCInterface.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+
+//--------------------------------------------------------------------------
+#ifndef Pythia8_HepMCInterface_H
+#define Pythia8_HepMCInterface_H
+
+//////////////////////////////////////////////////////////////////////////
+// Mikhail.Kirsanov@Cern.CH
+// Pythia8 I class
+//////////////////////////////////////////////////////////////////////////
+//
+
+#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 );
+
+    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;
+
+  };
+
+  ////////////////////////////
+  // 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.; }
+
+} // HepMC
+
+#endif  // Pythia8_HepMCInterface_H
+
+//--------------------------------------------------------------------------
diff --git a/PYTHIA8/pythia8130/include/Info.h b/PYTHIA8/pythia8130/include/Info.h
new file mode 100644 (file)
index 0000000..87a6cbf
--- /dev/null
@@ -0,0 +1,251 @@
+// Info.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+
+class Info {
+
+public:
+
+  // Constructor. 
+  Info() {} 
+
+  // Listing of most available information on current event.
+  void   list(ostream& os = cout);
+  
+  // 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;}
+
+  // 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;}   
+
+  // 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;}
+
+  // Impact parameter picture.
+  double bMI()            const {return (bIsSet) ? bMISave : 1.;}
+  double enhanceMI()      const {return (bIsSet) ? enhanceMISave : 1.;}
+
+  // 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;}
+
+  // 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];} 
+
+  // Number of times other steps have been carried out.
+  int    nISR()           const {return nISRSave;}
+  int    nFSRinProc()     const {return nFSRinProcSave;}
+  int    nFSRinRes()      const {return nFSRinResSave;}
+
+  // 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 = " ",
+    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);
+
+private:
+
+  // Store common beam quantities. 
+  int    idASave, idBSave;
+  double pzASave, eASave,mASave, pzBSave, eBSave, mBSave, eCMSave, sSave;
+
+  // 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;
+  string nameSave, nameSubSave;
+  vector<int>    codeMISave;
+  vector<double> pTMISave;
+
+  // 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);}
+
+  // 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) {
+    codeMISave.push_back(codeMIIn); pTMISave.push_back(pTMIIn);}
+
+  // 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 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 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;}
+
+  // Number of times the same error message is repeated.
+  static const int TIMESTOPRINT;
+
+  // Map for all error messages.
+  map<string, int> messages;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_Info_H
diff --git a/PYTHIA8/pythia8130/include/LHAFortran.h b/PYTHIA8/pythia8130/include/LHAFortran.h
new file mode 100644 (file)
index 0000000..2a1e667
--- /dev/null
@@ -0,0 +1,105 @@
+// LHAFortran.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+
+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] );
+    }
+    // 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]) ;
+    // Done.
+    return true;
+  }
+
+private:
+
+  // 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/pythia8130/include/LHAPDFInterface.h b/PYTHIA8/pythia8130/include/LHAPDFInterface.h
new file mode 100644 (file)
index 0000000..52cdaef
--- /dev/null
@@ -0,0 +1,75 @@
+// LHAPDFInterface.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 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);
+  }
+
+  // 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/pythia8130/include/LesHouches.h b/PYTHIA8/pythia8130/include/LesHouches.h
new file mode 100644 (file)
index 0000000..dcb2e48
--- /dev/null
@@ -0,0 +1,295 @@
+// LesHouches.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+// 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 {
+
+//**************************************************************************
+
+// 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;}
+
+  // 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);  
+
+  // 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(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) 
+    { id1Save = id1In; id2Save = id2In; x1Save = x1In; x2Save = x2In;
+    scalePDFSave = scalePDFIn; xpdf1Save = xpdf1In; xpdf2Save = xpdf2In;
+    pdfIsSetSave = true;}
+
+private:
+
+  // Event weighting and mixing strategy.
+  int strategySave;
+
+  // Beam particle properties.
+  int idBeamASave, idBeamBSave;
+  double eBeamASave, eBeamBSave;
+  int pdfGroupBeamASave, pdfGroupBeamBSave, pdfSetBeamASave, pdfSetBeamBSave;
+
+  // A nested class for processes...
+  class LHAProcess {
+  public:
+    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) { }
+    int idProc;
+    double xSecProc, xErrProc, xMaxProc;
+  } ;
+
+  // ...so that the process list can be kept as a vector.
+  vector<LHAProcess> processes;
+
+  // Store info on the selected process. 
+  int idProc;
+  double weightProc, scaleProc, alphaQEDProc, alphaQCDProc;
+
+  // A nested class for particles...
+  class LHAParticle {
+  public:
+    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) { }
+    int idPart, statusPart, mother1Part, mother2Part, col1Part, col2Part;
+    double pxPart, pyPart, pzPart, ePart, mPart, tauPart, spinPart;
+  } ;
+
+  // ...so that the particle list can be kept as a vector.
+  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() {}
+
+  // 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); 
+
+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/pythia8130/include/MiniStringFragmentation.h b/PYTHIA8/pythia8130/include/MiniStringFragmentation.h
new file mode 100644 (file)
index 0000000..dd43e5f
--- /dev/null
@@ -0,0 +1,78 @@
+// MiniStringFragmentation.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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, 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 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/pythia8130/include/MultipleInteractions.h b/PYTHIA8/pythia8130/include/MultipleInteractions.h
new file mode 100644 (file)
index 0000000..fd746d2
--- /dev/null
@@ -0,0 +1,218 @@
+// MultipleInteractions.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "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);
+
+  // 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);
+
+  // 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           pickedU;
+  
+};
+//**************************************************************************
+
+// The MultipleInteractions class contains the main methods for the 
+// generation of multiple parton-parton interactions in hadronic collisions.
+
+class MultipleInteractions {
+
+public:
+
+  // Constructor.
+  MultipleInteractions() {sudExpPT.resize(NBINS+1);}
+
+  // Initialize the generation process for given beams.
+  bool init( bool doMIinit, Info* infoPtrIn, BeamParticle* beamAPtrIn, 
+    BeamParticle* beamBPtrIn, SigmaTotal* sigmaTotPtrIn, 
+    ostream& os = cout);
+
+  // Reset impact parameter choice and update the CM energy.
+  void clear() {bIsSet = false; bSetInFirst = false;
+    eCM = infoPtr->eCM(); sCM = eCM * eCM;}
+
+  // 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);
+
+  // 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 reset = false, ostream& os = cout);
+  
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const bool   SHIFTFACSCALE;
+  static const int    NBINS;
+  static const double SIGMAFUDGE, RPT20, PT0STEP, SIGMASTEP, EXPPOWMIN,
+                      PROBATLOWB, BSTEP, BMAX, EXPMAX, KCONVERGE, 
+                      CONVERT2MB;
+
+  // Initialization data, read from Settings.
+  int    pTmaxMatch, alphaSorder, alphaEMorder, bProfile, 
+         processLevel, nQuarkIn, nSample;
+  double alphaSvalue, Kfactor, pT0Ref, ecmRef, ecmPow, 
+         pTmin, coreRadius, coreFraction, expPow;
+
+  // Other initialization data.
+  bool   hasLowPow;
+  double eCM, sCM, pT0, pT20, pT2min, pTmax, pT2max, pT20R, pT20minR, 
+         pT20maxR, pT20min0maxR, pT2maxmin, sigmaND, pT4dSigmaMax, 
+         pT4dProbMax, dSigmaApprox, sigmaInt, zeroIntCorr, normOverlap, 
+         nAvg, kNow, normPi, bAvg, bDiv, probLowB, radius2B, radius2C, 
+         fracA, fracB, fracC, fracAhigh, fracBhigh, fracChigh, fracABChigh, 
+         expRev, cDiv, cMax;
+  vector<double> sudExpPT;
+
+  // Properties specific to current system.
+  int    id1, id2;
+  double bNow, enhanceB, pT2, pT2shift, pT2Ren, pT2Fac, x1, x2, xT, xT2, 
+         tau, y, sHat, tHat, uHat, alpS, alpEM, xPDF1now, xPDF2now;
+  bool   bIsSet, bSetInFirst, isAtLowB;
+
+  // Pointer to various information on the generation.
+  Info*  infoPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle* beamAPtr;
+  BeamParticle* beamBPtr;
+
+  // Pointer to total cross section parametrization.
+  SigmaTotal* sigmaTotPtr;
+
+  // Collections of parton-level 2 -> 2 cross sections. Selected one.
+  SigmaMultiple sigma2gg, sigma2qg, sigma2qqbarSame, sigma2qq;
+  SigmaProcess* dSigmaDtSel;
+
+  // Statistics on generated 2 -> 2 processes.
+  map<int, int> nGen;
+
+  // alphaStrong and alphaEM calculations.
+  AlphaStrong alphaS;
+  AlphaEM alphaEM;
+
+  // 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 sigmaPT2(bool isFirst = false);
+
+  // 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/pythia8130/include/ParticleData.h b/PYTHIA8/pythia8130/include/ParticleData.h
new file mode 100644 (file)
index 0000000..e443d02
--- /dev/null
@@ -0,0 +1,602 @@
+// ParticleData.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+// DecayTable contains all decay channels of a particle.
+// ParticleDataEntry contains info on a single particle species.
+// ParticleDataTable  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"
+
+namespace Pythia8 {
+
+//**************************************************************************
+
+// Forward reference to the ResonanceWidths class.
+class ResonanceWidths;
+  
+//**************************************************************************
+
+// 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.), 
+    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 all decay channels of a particle.
+
+class DecayTable {
+
+public:
+
+  // Constructor.
+  DecayTable() {}
+
+  // Overload index operator to access a channel in the decay table.
+  DecayChannel& operator[](int i){return channel[i];}
+  const DecayChannel& operator[](int i) const {return channel[i];}
+
+  // 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) { 
+    channel.push_back( DecayChannel( onMode, bRatio, meMode, prod0, 
+    prod1, prod2, prod3, prod4, prod5, prod6, prod7) ); }
+
+  // Decay table size.
+  int size() const {return channel.size();}
+
+  // Reset to empty decay table..
+  void clear() {channel.resize(0);}
+
+  // Rescale sum of branching ratios to unity.
+  void rescaleBR(double newSumBR = 1.);
+
+private:
+
+  // A vector containing all the decay channels of the particle.
+  vector<DecayChannel> channel;
+
+};
+
+//**************************************************************************
+
+// 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();
+
+  // Initialize static pointer to Info for error messages.
+  static void initPtr(Info* infoPtrIn) {infoPtr = infoPtrIn;}
+
+  // Initialize static data members.
+  static void initStatic();
+
+  // Initialization of some particle flags.
+  void setDefaults();
+
+  // Prepare for and pick mass according to Breit-Wigner.
+  void initBWmass(); 
+  double mass(); 
+
+  // Calculate running mass - for quarks only! (Else normal mass.)
+  double mRun(double mH);
+
+  // Random choice of decay channel according to branching ratios.
+  bool preparePick(int idSgn, double mHat = 0., int idInFlav = 0);
+  DecayChannel& pickChannel();
+
+  // 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 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;}
+
+  // Change several values at the same time (or set if not set before).
+  void setNames(string nameIn, string antiNameIn) {nameSave = nameIn; 
+    antiNameSave = antiNameIn; hasAntiSave = true; if (toLower(antiNameIn) 
+    == "void") hasAntiSave = false; hasChangedSave = true;}
+  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;}
+  void setHasChanged(bool hasChangedIn) {hasChangedSave = hasChangedIn;
+    for (int i = 0; i < decay.size(); ++i) 
+      decay[i].setHasChanged(hasChangedIn);}
+  void rescaleBR(double newSumBR = 1.) {decay.rescaleBR(newSumBR);}
+
+  // 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 constituentMass()        const { return constituentMassSave; } 
+  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; }
+
+  // Give back other quantities.
+  bool   hasChanged()     const { if (hasChangedSave) return true;
+         for (int i = 0; i < decay.size(); ++i) 
+         if (decay[i].hasChanged()) return true; return false;}
+  bool   useBreitWigner() const { return (modeBWnow > 0); }
+  bool   canDecay()       const { return (decay.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;
+
+  // The decay table.
+  DecayTable decay;
+
+  // Access methods stored in ResonanceWidths.
+  void   setResonancePtr(ResonanceWidths* resonancePtrIn); 
+  ResonanceWidths* getResonancePtr() const {return resonancePtr;}
+  void   resInit();
+  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:
+
+  // Static initialization data, normally only set once.
+  static int    modeBreitWigner;
+  static double maxEnhanceBW, mQRun[7], Lambda5Run;
+
+  // Constants: could only be changed in the code itself.
+  static const int    INVISIBLENUMBER, INVISIBLETABLE[29];
+  static const double MAXTAU0FORDECAY,MINMASSRESONANCE, NARROWMASS,
+                      CONSTITUENTMASSTABLE[6];
+
+  // Pointer to various information on the generation.
+  static Info* infoPtr;
+
+  // 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;   
+
+  // Summed branching ratio of currently open channels.
+  double currentBRSum;
+
+  // Pointer to ResonanceWidths object; only used for some particles.
+  ResonanceWidths* resonancePtr;  
+
+  // Set constituent mass. 
+  void setConstituentMass();
+
+  // Useful functions for string handling.
+  static string toLower(const string& name);
+
+};
+
+//**************************************************************************
+
+// This class holds a map of all ParticleDataEntries.
+
+class ParticleDataTable {
+
+public:
+
+  // Constructor.
+  ParticleDataTable() {}
+
+  // Initialize static pointer.
+  static void initPtr(Info* infoPtrIn) {infoPtr = infoPtrIn;}
+  // Read in database from specific file.
+  static bool init(string startFile = "../xmldoc/ParticleData.xml") {
+    return readXML(startFile);}
+
+  // Overwrite existing database by reading from specific file.
+  static bool reInit(string startFile, bool xmlFormat = true) {
+    return (xmlFormat) ? readXML(startFile) : readFF(startFile);}
+
+  // Initialize the handling of Breit-Wigner mass selection.
+  static void initBWmass() {
+    for (map<int, ParticleDataEntry>::iterator pdtEntry = pdt.begin(); 
+      pdtEntry != pdt.end(); ++pdtEntry) pdtEntry->second.initBWmass(); }
+
+  // Initialize the special handling of resonances in ResonanceWidths.
+  static void initResonances(vector<ResonanceWidths*> resonancePtrs, 
+    bool reInit = false);
+
+  // Calculate a mass, picked according to Breit-Wigner.
+  static double mass(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mass() : 0. ; } 
+
+  // Calculate running mass - for quarks only! (Else normal mass.)
+  static double mRun(int idIn, double mH) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mRun(mH) : 0. ; } 
+
+  // Read or list whole (or part of) database from/to an XML file.
+  static bool readXML(string inFile, bool reset = true) ; 
+  static void listXML(string outFile) ; 
+
+  // Read or list whole (or part of) database from/to a free format file.
+  static bool readFF(string inFile, bool reset = true) ; 
+  static void listFF(string outFile) ; 
+
+  // Read in one update from a single line.
+  static bool readString(string lineIn, bool warn = true, 
+    ostream& os = cout) ; 
+
+  // Print out table of whole database, or of only part of it.
+  static void listAll(ostream& os = cout) {list(false, true, os);} 
+  static void listChanged(ostream& os = cout) {list(true, false, os);} 
+  static void listChanged(bool changedRes, ostream& os = cout) 
+    {list(true, changedRes, os);} 
+  static void list(bool changedOnly = false, bool changedRes = true, 
+    ostream& os = cout) ; 
+  static void list(int idList, ostream& os = cout) {
+    vector<int> idListTemp; idListTemp.push_back(idList); 
+    list( idListTemp, os);} 
+  static void list(vector<int> idList, ostream& os = cout) ; 
+
+  // Check that table makes sense, especially for decays.
+  static void checkTable(ostream& os = cout) {checkTable(1, os);};
+  static void checkTable(int verbosity, ostream& os = cout) ;
+  // Add new entry.
+  static 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); }  
+  static 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); }  
+
+  // Query existence of an entry.
+  static 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 pointer to entry.
+  static ParticleDataEntry* particleDataPtr(int idIn) {
+    return (isParticle(idIn)) ? &pdt[abs(idIn)] : &pdt[0]; }
+
+  // Return the id of the sequentially next particle stored in table.
+  static int nextId(int idIn) ;
+
+  // Change current values one at a time (or set if not set before).
+  static void name(int idIn, string nameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setName(nameIn); }
+  static void antiName(int idIn, string antiNameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setAntiName(antiNameIn); }
+  static void spinType(int idIn, int spinTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setSpinType(spinTypeIn); }
+  static void chargeType(int idIn, int chargeTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setChargeType(chargeTypeIn); }
+  static void colType(int idIn, int colTypeIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setColType(colTypeIn); }
+  static void m0(int idIn, double m0In) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setM0(m0In); }
+  static void mWidth(int idIn, double mWidthIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMWidth(mWidthIn); }
+  static void mMin(int idIn, double mMinIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMMin(mMinIn); }
+  static void mMax(int idIn, double mMaxIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMMax(mMaxIn); }
+  static void tau0(int idIn, double tau0In) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setTau0(tau0In); }
+  static void isResonance(int idIn, bool isResonanceIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setIsResonance(isResonanceIn); }
+  static void mayDecay(int idIn, bool mayDecayIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setMayDecay(mayDecayIn); }
+  static void doExternalDecay(int idIn, bool doExternalDecayIn) {
+    if (isParticle(idIn)) 
+    pdt[abs(idIn)].setDoExternalDecay(doExternalDecayIn); }
+  static void isVisible(int idIn, bool isVisibleIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setIsVisible(isVisibleIn); }
+  static void doForceWidth(int idIn, bool doForceWidthIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setDoForceWidth(doForceWidthIn); }
+
+  // Change several values at the same time (or set if not set before).
+  static void names(int idIn, string nameIn, string antiNameIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setNames(nameIn, antiNameIn); }
+  static 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); }  
+  static void hasChanged(int idIn, bool hasChangedIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].setHasChanged(hasChangedIn); }
+  static void rescaleBR(int idIn, double newSumBR = 1.) {
+    if (isParticle(idIn)) pdt[abs(idIn)].rescaleBR(newSumBR); }
+  // Give back current values. 
+  static bool hasAnti(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].hasAnti() : false ; } 
+  static string name(int idIn) {
+    return (isParticle(abs(idIn))) ? pdt[abs(idIn)].name(idIn) : " "; }
+  static int spinType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].spinType() : 0 ; } 
+  static int chargeType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].chargeType(idIn) : 0 ; } 
+  static double charge(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].charge(idIn) : 0 ; } 
+  static int colType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].colType(idIn) : 0 ; } 
+  static double m0(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0() : 0. ; } 
+  static double constituentMass(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].constituentMass() : 0. ; } 
+  static double mWidth(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mWidth() : 0. ; } 
+  static double mMin(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mMin() : 0. ; } 
+  static double m0Min(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0Min() : 0. ; } 
+  static double mMax(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mMax() : 0. ; } 
+  static double m0Max(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].m0Max() : 0. ; } 
+  static double tau0(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].tau0() : 0. ; } 
+  static bool isResonance(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isResonance() : false ; } 
+  static bool mayDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].mayDecay() : false ; } 
+  static bool doExternalDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].doExternalDecay() : false ; }
+  static bool isVisible(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isVisible() : false ; } 
+  static bool doForceWidth(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].doForceWidth() : false ; } 
+  // Give back other quantities.
+  static bool hasChanged(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].hasChanged() : false ; } 
+  static bool useBreitWigner(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].useBreitWigner() : false ; } 
+  static bool canDecay(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].canDecay() : false ; }
+  static bool isLepton(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isLepton() : false ; } 
+  static bool isQuark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isQuark() : false ; } 
+  static bool isGluon(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isGluon() : false ; } 
+  static bool isDiquark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isDiquark() : false ; } 
+  static bool isHadron(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isHadron() : false ; } 
+  static bool isMeson(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isMeson() : false ; } 
+  static bool isBaryon(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isBaryon() : false ; } 
+  static bool isOctetHadron(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].isOctetHadron() : false ; } 
+  static int heaviestQuark(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].heaviestQuark(idIn) : 0 ; }  
+  static int baryonNumberType(int idIn) {
+    return isParticle(idIn) ? pdt[abs(idIn)].baryonNumberType(idIn) : 0 ; }  
+
+  // Access methods stored in ResonanceWidths.
+  static void resInit(int idIn) {
+    if (isParticle(idIn)) pdt[abs(idIn)].resInit();}
+  static 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.;}
+  static double resWidthOpen(int idIn, double mHat, int idInFlav = 0) {
+    return isParticle(idIn) ? pdt[abs(idIn)].resWidthOpen(idIn, mHat, 
+    idInFlav) : 0.;}
+  static double resWidthStore(int idIn, double mHat, int idInFlav = 0) {
+    return isParticle(idIn) ? pdt[abs(idIn)].resWidthStore(idIn, mHat, 
+    idInFlav) : 0.;}
+  static double resOpenFrac(int id1In, int id2In = 0, int id3In = 0);
+  static double resWidthRescaleFactor(int idIn) { return isParticle(idIn) 
+    ? pdt[abs(idIn)].resWidthRescaleFactor() : 0.;}
+  static double resWidthChan(int idIn, double mHat, int idAbs1 = 0, 
+    int idAbs2 = 0) { return isParticle(idIn) 
+    ? pdt[abs(idIn)].resWidthChan( mHat, idAbs1, idAbs2) : 0.;}
+
+private:
+
+  // Pointer to various information on the generation.
+  static Info*  infoPtr;
+
+  // All particle data stored in a map.
+  static map<int, ParticleDataEntry> pdt;
+
+  // Pointer to current particle (e.g. when reading decay channels).
+  static ParticleDataEntry* particlePtr;
+
+  // Flag that initialization has been performed.
+  static bool isInit;
+
+  // Useful functions for string handling.
+  static string toLower(const string& name);
+  static bool   boolString(string tag);
+  static string attributeValue(string line, string attribute);
+  static bool   boolAttributeValue(string line, string attribute);
+  static int    intAttributeValue(string line, string attribute);
+  static double doubleAttributeValue(string line, string attribute);
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ParticleData_H
diff --git a/PYTHIA8/pythia8130/include/ParticleDecays.h b/PYTHIA8/pythia8130/include/ParticleDecays.h
new file mode 100644 (file)
index 0000000..0530094
--- /dev/null
@@ -0,0 +1,138 @@
+// ParticleDecays.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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, 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;
+  static const double MSAFEDALITZ, WTCORRECTION[11];
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // 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;
+  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/pythia8130/include/PartonDistributions.h b/PYTHIA8/pythia8130/include/PartonDistributions.h
new file mode 100644 (file)
index 0000000..4d7872e
--- /dev/null
@@ -0,0 +1,192 @@
+// PartonDistributions.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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.
+// GRV94L: derived class for the GRV 94L parton densities.
+// CTEQ5L: derived class for the CTEQ 5L parton densities.
+// LHAPDFinterface: derived class for interface to the LHAPDF library.
+// 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; idSav = 9; xSav = -1.; 
+    Q2Sav = -1.; isSet = true; isInit = false;}
+
+  // Destructor.
+  virtual ~PDF() {}
+
+  // Confirm that PDF has been set up (important for LHAPDF).
+  bool isSetup() {return isSet;}
+
+  // 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, idSav;
+  double xSav, Q2Sav;
+  double xu, xd, xubar, xdbar, xs, xc, xb, xg, xlepton, xgamma,
+         xuVal, xuSea, xdVal, xdSea;
+  bool   isSet, isInit, hasLimits; 
+
+  // Update parton densities.
+  virtual void xfUpdate(int id, double x, double Q2) = 0; 
+
+};
+//**************************************************************************
+
+// Gives the GRV 94 L (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 GRV 94 L (leading order) parton distribution function set
+// in parametrized form. Authors: M. Glueck, E. Reya and A. Vogt.
+
+class CTEQ5L : public PDF {
+
+public:
+
+  // Constructor.
+  CTEQ5L(int idBeamIn = 2212) : PDF(idBeamIn) {}
+
+private:
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+};
+//**************************************************************************
+
+// 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];
+
+  // Keep track of latest initialized PDF, so does not have to repeat.
+  static string latestSetName;
+  static int    latestMember, latestNSet;   
+
+};
+//**************************************************************************
+
+// 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;
+
+  // Update PDF values.
+  void xfUpdate(int id, double x, double Q2);
+
+  // The 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/pythia8130/include/PartonLevel.h b/PYTHIA8/pythia8130/include/PartonLevel.h
new file mode 100644 (file)
index 0000000..42d05fe
--- /dev/null
@@ -0,0 +1,114 @@
+// PartonLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "PythiaStdlib.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SpaceShower.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, BeamParticle* beamAPtrIn, 
+    BeamParticle* beamBPtrIn, 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() {multi.accumulate();}
+  void statistics(bool reset = false) {if (doMI) multi.statistics(reset);}
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int NTRY;
+
+  // Initialization data, mainly read from Settings.
+  bool   doMI, doISR, doFSRduringProcess, doFSRafterProcess, 
+         doFSRinResonances, doRemnants, doSecondHard, doMIinit, 
+         hasLeptonBeams, hasPointLeptons, canVetoPT, canVetoStep;
+
+  // Event generation strategy. Number of steps. Maximum pT scales.
+  bool   doVeto;
+  int    nMI, nISR, nFSRinProc, nFSRinRes, nISRhard, nFSRhard, 
+         typeLatest, nVetoStep, typeVetoStep, iSysNow;
+  double pTsaveMI, pTsaveISR, pTsaveFSR, pTvetoPT;
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // Pointers to the two incoming beams.
+  BeamParticle* beamAPtr;
+  BeamParticle* beamBPtr;
+
+  // 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 class for multiple interactions.
+  MultipleInteractions multi;
+
+  // The generator class to construct beam-remnant kinematics. 
+  BeamRemnants remnants;
+
+  // Set up the hard process, excluding subsequent resonance decays.
+  void setupHardSys( Event& process, Event& event);
+  // Keep track of how much of hard process has been handled.
+  int nHardDone;
+
+  // Set up an unresolved process, i.e. elastic or diffractive.
+  bool setupUnresolvedSys( Event& process, Event& event);
+
+  // Perform showers in resonance decay chains.
+  int 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/pythia8130/include/PhaseSpace.h b/PYTHIA8/pythia8130/include/PhaseSpace.h
new file mode 100644 (file)
index 0000000..7fc3942
--- /dev/null
@@ -0,0 +1,458 @@
+// PhaseSpace.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "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(SigmaProcess* sigmaProcessPtrIn, Info* infoPtrIn, 
+    BeamParticle* beamAPtrIn, BeamParticle* beamBPtrIn,
+    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;
+
+  // Pointers to incoming beams.
+  BeamParticle* beamAPtr;
+  BeamParticle* beamBPtr;
+  
+  // 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;
+  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, 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, 
+         intY01, intY2, intY34, 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;
+
+  // Kinematics properties specific to 2 -> 2 diffractive.
+  bool   isDiffA, isDiffB;
+  double m3ElDiff, m4ElDiff, cRes, sResXB, sResAX, sProton,
+         s1, s2, bMin, lambda12, lambda34, tLow, tUpp, tAux;
+
+};
+//**************************************************************************
+
+// 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 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); 
+
+  // Dummy, since kinematics available in Les Houches object. 
+  virtual bool finalKin() {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/pythia8130/include/ProcessContainer.h b/PYTHIA8/pythia8130/include/ProcessContainer.h
new file mode 100644 (file)
index 0000000..eb4f38b
--- /dev/null
@@ -0,0 +1,164 @@
+// ProcessContainer.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "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) 
+    : sigmaProcessPtr(sigmaProcessPtrIn), phaseSpacePtr(0) {} 
+
+  // Destructor.
+  ~ProcessContainer() {delete phaseSpacePtr; delete sigmaProcessPtr;}
+  
+  // Initialize phase space and counters.
+  bool init(Info* infoPtrIn, BeamParticle* beamAPtr, BeamParticle* beamBPtr, 
+    AlphaStrong* alphaSPtr, AlphaEM* alphaEMPtr, SigmaTotal* sigmaTotPtr, 
+    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();}
+
+  // 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();}
+
+  // 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.
+  SigmaProcess*    sigmaProcessPtr;
+
+  // Pointer to the phase space generator.
+  PhaseSpace*      phaseSpacePtr;
+
+  // Pointer to various information on the generation.
+  Info*            infoPtr;
+
+  // Pointer to ResonanceDecays object for sequential resonance decays.
+  ResonanceDecays* resDecaysPtr;
+
+  // Pointer to LHAup for generating external events.
+  LHAup*           lhaUpPtr;
+
+  // Info on process.
+  bool   isMinBias, isResolved, isDiffA, isDiffB, isLHA, allowNegSig,
+         hasOctetOnium, isSameSave;
+  int    lhaStrat, lhaStratAbs;
+
+  // Statistics on generation process. (Long integers just in case.)
+  int    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);
+  // Initialization of a second hard process.
+  bool init2(vector<ProcessContainer*>& container2Ptrs);
+
+};
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_ProcessContainer_H
diff --git a/PYTHIA8/pythia8130/include/ProcessLevel.h b/PYTHIA8/pythia8130/include/ProcessLevel.h
new file mode 100644 (file)
index 0000000..d351287
--- /dev/null
@@ -0,0 +1,135 @@
+// ProcessLevel.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "SusyLesHouches.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, BeamParticle* beamAPtrIn, 
+    BeamParticle* beamBPtrIn, 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: 
+
+  // Generic info for process generation.
+  bool   doSecondHard, allHardSame, noneHardSame, someHardSame, doResDecays;
+  int    nImpact, startColTag2;
+  double 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;
+
+  // Pointers to the two incoming beams.
+  BeamParticle*   beamAPtr;
+  BeamParticle*   beamBPtr;
+
+  // Pointer to SigmaTotal object needed to handle soft QCD processes.
+  SigmaTotal*     sigmaTotPtr;
+
+  // 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;
+
+  // Common alphaStrong and alphaElectromagnetic calculation for SigmaProcess.
+  AlphaStrong     alphaS;
+  AlphaEM         alphaEM;
+
+  // Initialization routine for SUSY spectra.
+  bool initSLHA();
+
+  // 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/pythia8130/include/Pythia.h b/PYTHIA8/pythia8130/include/Pythia.h
new file mode 100644 (file)
index 0000000..8e67e3e
--- /dev/null
@@ -0,0 +1,263 @@
+// Pythia.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 "ProcessLevel.h"
+#include "PythiaStdlib.h"
+#include "ResonanceWidths.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "SpaceShower.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, bool warn = true, int subrun = SUBRUNDEFAULT);
+  bool readFile(string fileName, int subrun) {
+    return readFile(fileName, true, subrun);}
+
+  // Possibility to pass in pointers to PDF's.
+  bool setPDFPtr( PDF* pdfAPtrIn, PDF* pdfBPtrIn, PDF* pdfHardAPtrIn = 0, 
+    PDF* pdfHardBPtrIn = 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;} 
+
+  // 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) {lhaUpPtr->listEvent(os);}
+
+  // Main routine to provide final statistics on generation.
+  void statistics(bool all = false, bool reset = true);
+
+  // 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 - is static but declared here for ease of use.
+  Settings settings;
+
+  // ParticleDataTable - is static but declared here for ease of use.
+  ParticleDataTable particleData;
+
+  // SusyLesHouches - SLHA object for interface to SUSY spectra.
+  SusyLesHouches slha;
+
+private: 
+
+  // Constants: could only be changed in the code itself.
+  static const int NTRY, SUBRUNDEFAULT;
+
+  // Initialization data, extracted from database.
+  bool   doProcessLevel, doPartonLevel, doHadronLevel, checkEvent;
+  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;
+
+  // 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; 
+
+  // Keep track when "new" has been used and needs a "delete" for PDF's.  
+  bool useNewPdfA, useNewPdfB, useNewPdfHard;
+
+  // The two incoming beams.
+  BeamParticle beamA;
+  BeamParticle beamB;
+
+  // 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();
+
+  // Calculate kinematics at initialization.
+  bool initKinematics();
+
+  // Initialize tunes to e+e- and pp/ppbar data.
+  void initTunes();
+
+  // 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/pythia8130/include/Pythia6Interface.h b/PYTHIA8/pythia8130/include/Pythia6Interface.h
new file mode 100644 (file)
index 0000000..10fa0ec
--- /dev/null
@@ -0,0 +1,78 @@
+// Pythia6Interface.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 Pythia 6.4 f77 external linkage to C++.
+// All required code is contained here, i.e. there is no matching .cc file.
+
+#ifndef Pythia8_Pythia6Interface_H
+#define Pythia8_Pythia6Interface_H
+
+namespace Pythia8 {
+
+//**************************************************************************
+
+// Declare the f77 subroutines that may be used.
+
+extern "C" {
+
+  extern void pygive_(const char*, int);
+
+  extern void pyinit_(const char*, const char*, const char*, double&,
+    int, int, int);
+
+  extern void pyupin_();
+
+  extern void pyupev_();
+
+  extern void pylist_(int&);
+
+  extern void pystat_(int&);
+
+}
+
+//**************************************************************************
+
+// Interfaces to the above routines, to make the C++ calls similar to f77.
+
+class Pythia6Interface {
+
+public:
+
+  // Give in a command to change a setting.
+  static void pygive(const string cmnd) { 
+    const char* cstring = cmnd.c_str(); int len = cmnd.length(); 
+    pygive_(cstring, len);
+  }
+
+  // Initialize the generation for the given beam confiuration.
+  static void pyinit(const string frame, const string beam, 
+    const string target, double wIn) { 
+    const char* cframe = frame.c_str(); int lenframe = frame.length();
+    const char* cbeam = beam.c_str(); int lenbeam = beam.length();
+    const char* ctarget = target.c_str(); int lentarget = target.length();
+    pyinit_(cframe, cbeam, ctarget, wIn, lenframe, lenbeam, lentarget); 
+  }
+  
+  // Fill the initialization information in the HEPRUP commonblock.
+  static void pyupin() {pyupin_();}
+
+  // Generate the next hard process and 
+  // fill the event information in the HEPEUP commonblock
+  static void pyupev() {pyupev_();}
+
+  // List the event at the process level.
+  static void pylist(int mode) {pylist_(mode);}
+
+  // Print statistics on the event generation process.
+  static void pystat(int mode) {pystat_(mode);}
+
+};
+
+//**************************************************************************
+
+
+} // end namespace Pythia8
+
+#endif // Pythia8_Pythia6Interface_H
diff --git a/PYTHIA8/pythia8130/include/PythiaComplex.h b/PYTHIA8/pythia8130/include/PythiaComplex.h
new file mode 100644 (file)
index 0000000..9298f75
--- /dev/null
@@ -0,0 +1,21 @@
+// PythiaComplex.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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/pythia8130/include/PythiaStdlib.h b/PYTHIA8/pythia8130/include/PythiaStdlib.h
new file mode 100644 (file)
index 0000000..cfc1313
--- /dev/null
@@ -0,0 +1,82 @@
+// PythiaStdlib.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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).
+
+#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>
+
+// 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; 
+// 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));}
+
+} // end namespace Pythia8
+
+#endif // Pythia8_PythiaStdlib_H
diff --git a/PYTHIA8/pythia8130/include/ResonanceDecays.h b/PYTHIA8/pythia8130/include/ResonanceDecays.h
new file mode 100644 (file)
index 0000000..d974465
--- /dev/null
@@ -0,0 +1,71 @@
+// ResonanceDecays.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 pointer to Info for error messages.
+  void init(Info* infoPtrIn) {infoPtr = infoPtrIn;}
+  // 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, WTCORRECTION[11];
+
+  // Pointer to various information on the generation.
+  Info* infoPtr;
+
+  // 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/pythia8130/include/ResonanceWidths.h b/PYTHIA8/pythia8130/include/ResonanceWidths.h
new file mode 100644 (file)
index 0000000..4d45d85
--- /dev/null
@@ -0,0 +1,635 @@
+// ResonanceWidths.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 DecayTable;
+class ParticleDataEntry;
+class AlphaStrong;
+class AlphaEM;
+  
+//**************************************************************************
+
+// The ResonanceWidths is the base class. Also used for generic resonaces.
+
+class ResonanceWidths {
+
+public: 
+
+  // Destructor.
+  virtual ~ResonanceWidths() {}
+
+  // Initialize static data members in base class.
+  static void initStatic(Info* infoPtrIn);
+
+  // Set up standard properties.
+  bool initBasic(int idResIn);
+  // Calculate and store partial and total widths at the nominal mass. 
+  void init();
+
+  // 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() {}
+
+  // Static initialization data, normally only set once.
+  static int    alphaSorder, alphaEMorder;
+  static double alphaSvalue, minWidth, minThreshold;
+
+  // Static alphaStrong and alphaElectromagnetic calculation.
+  static AlphaStrong alphaS;
+  static AlphaEM     alphaEM;
+
+  // Constants: could only be changed in the code itself.
+  static const int    NPOINT;
+  static const double MASSMARGIN;
+
+  // Pointer to various information on the generation.
+  static Info* infoPtr;
+
+  // Pointer to properties of the particle species.
+  ParticleDataEntry* particlePtr;
+
+  // Particle properties always locally present.
+  int    idRes, hasAntiRes;
+  bool   doForceWidth;
+  double 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; 
+  // 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);} 
+
+};
+  
+//**************************************************************************
+
+// 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.
+  double kappaMG;
+  // 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/pythia8130/include/Settings.h b/PYTHIA8/pythia8130/include/Settings.h
new file mode 100644 (file)
index 0000000..42aa109
--- /dev/null
@@ -0,0 +1,235 @@
+// Settings.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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; and for error statistics.
+// 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,
+    bool hasMaxIn = false, int minIn = 0,  int maxIn = 0) :  name(nameIn), 
+    valNow(defaultIn), valDefault(defaultIn), hasMin(hasMinIn),
+    hasMax(hasMaxIn), valMin(minIn), valMax(maxIn) { }
+
+  // Data members.
+  string name;
+  int    valNow, valDefault;
+  bool   hasMin, hasMax;
+  int    valMin, valMax;
+
+};
+
+//**************************************************************************
+
+// Class for double parms (where parm is shorthand for parameter).
+
+class Parm {
+
+public:
+
+  // Constructor
+  Parm(string nameIn = " ", double defaultIn = 0., 
+    bool hasMinIn = false, bool hasMaxIn = false, double minIn = 0., 
+    double maxIn = 0.) :  name(nameIn), valNow(defaultIn), 
+    valDefault(defaultIn), hasMin(hasMinIn), hasMax(hasMaxIn), 
+    valMin(minIn), valMax(maxIn) { }
+
+  // Data members.
+  string name;
+  double valNow, valDefault;
+  bool   hasMin, hasMax;
+  double valMin, valMax;
+
+};
+
+//**************************************************************************
+
+// Class for string words.
+
+class Word {
+
+public:
+
+  // Constructor
+  Word(string nameIn = " ", string defaultIn = " ") : name(nameIn), 
+    valNow(defaultIn) , valDefault(defaultIn) { }
+
+  // Data members.
+  string name, valNow, valDefault;
+
+};
+
+//**************************************************************************
+
+// This class holds info on flags (bool), modes (int), 
+// parms (double) and words (string).
+
+class Settings {
+
+public:
+
+  // Constructor.
+  Settings() {}
+
+  // Initialize static pointer.
+  static void initPtr(Info* infoPtrIn) {infoPtr = infoPtrIn;}
+  // Read in database from specific file.
+  static bool init(string startFile = "../xmldoc/Index.xml", 
+    bool append = false, ostream& os = cout) ;
+
+  // Overwrite existing database by reading from specific file.
+  static bool reInit(string startFile = "../xmldoc/Index.xml") ;
+
+  // Read in one update from a single line.
+  static bool readString(string line, bool warn = true, 
+    ostream& os = cout) ; 
+  // Write updates or everything to user-defined file.
+  static bool writeFile(ostream& os = cout, bool writeAll = false) ;
+  static bool writeFile(string toFile, bool writeAll = false) ;
+
+  // Print out table of database, either all or only changed ones,
+  // or ones containing a given string.
+  static void listAll(ostream& os = cout) { 
+    list( true, false, " ", os); } 
+  static void listChanged(ostream& os = cout) { 
+    list (false, false, " ", os); } 
+  static void list(string match, ostream& os = cout) { 
+    list (false, true, match, os); } 
+
+  // Reset all values to their defaults.
+  static void resetAll() ;
+
+  // Query existence of an entry.
+  static bool isFlag(string keyIn) {
+    return (flags.find(toLower(keyIn)) != flags.end()); }
+  static bool isMode(string keyIn) { 
+    return (modes.find(toLower(keyIn)) != modes.end()); }
+  static bool isParm(string keyIn) {
+    return (parms.find(toLower(keyIn)) != parms.end()); }
+  static bool isWord(string keyIn) {
+    return (words.find(toLower(keyIn)) != words.end()); }
+  // Add new entry.
+  static void addFlag(string keyIn, bool defaultIn) {
+    flags[toLower(keyIn)] = Flag(keyIn, defaultIn); }  
+  static void addMode(string keyIn, int defaultIn, bool hasMinIn, 
+    bool hasMaxIn, int minIn, int maxIn) { modes[toLower(keyIn)] 
+    = Mode(keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn); }      
+  static void addParm(string keyIn, double defaultIn, bool hasMinIn, 
+    bool hasMaxIn, double minIn, double maxIn) { parms[toLower(keyIn)] 
+    = Parm(keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn); }  
+  static void addWord(string keyIn, string defaultIn) {
+    words[toLower(keyIn)] = Word(keyIn, defaultIn); }  
+
+  // Give back current value, with check that key exists. 
+  static bool   flag(string keyIn);
+  static int    mode(string keyIn);
+  static double parm(string keyIn);
+  static string word(string keyIn); 
+  
+  // Change current value, respecting limits.
+  static void flag(string keyIn, bool nowIn); 
+  static void mode(string keyIn, int nowIn);
+  static void parm(string keyIn, double nowIn); 
+  static void word(string keyIn, string nowIn); 
+
+  // Change current value, disregarding limits.
+  static void forceMode(string keyIn, int nowIn) { 
+    if (isMode(keyIn)) modes[toLower(keyIn)].valNow = nowIn; }
+  static void forceParm(string keyIn, double nowIn) { 
+    if (isParm(keyIn)) parms[toLower(keyIn)].valNow = nowIn; }
+     
+  // Restore current value to default. 
+  static void resetFlag(string keyIn) {
+    if (isFlag(keyIn)) flags[toLower(keyIn)].valNow 
+      = flags[toLower(keyIn)].valDefault ; }
+  static void resetMode(string keyIn) {
+    if (isMode(keyIn)) modes[toLower(keyIn)].valNow 
+      = modes[toLower(keyIn)].valDefault ; }
+  static void resetParm(string keyIn) {
+    if (isParm(keyIn)) parms[toLower(keyIn)].valNow 
+      = parms[toLower(keyIn)].valDefault ; }
+  static void resetWord(string keyIn) {
+    if (isWord(keyIn)) words[toLower(keyIn)].valNow 
+      = words[toLower(keyIn)].valDefault ; }
+
+private:
+
+  // Pointer to various information on the generation.
+  static Info* infoPtr;
+
+  // Map for bool flags.
+  static map<string, Flag> flags;
+
+  // Map for integer modes.
+  static map<string, Mode> modes;
+
+  // Map for double parms.
+  static map<string, Parm> parms;
+
+  // Map for string words.
+  static map<string, Word> words;
+
+  // Flag that initialization has been performed.
+  static bool isInit;
+
+  // Print out table of database, called from listAll and listChanged.
+  static void list(bool listAll, bool listString, string match,
+    ostream& os = cout) ; 
+
+  // Useful functions for string handling.
+  static string toLower(const string& name);
+  static bool   boolString(string tag);
+  static string attributeValue(string line, string attribute);
+  static bool   boolAttributeValue(string line, string attribute);
+  static int    intAttributeValue(string line, string attribute);
+  static double doubleAttributeValue(string line, string attribute);
+
+};
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_Settings_H
diff --git a/PYTHIA8/pythia8130/include/SigmaCompositeness.h b/PYTHIA8/pythia8130/include/SigmaCompositeness.h
new file mode 100644 (file)
index 0000000..bc22461
--- /dev/null
@@ -0,0 +1,184 @@
+// SigmaCompositeness.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 compositiness-process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma(1/2)Process.
+
+#ifndef Pythia8_SigmaCompositeness_H
+#define Pythia8_SigmaCompositeness_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for q g -> q^* (excited quark state).
+
+class Sigma1qg2qStar : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1qg2qStar(int idqIn) : idq(idqIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for q* decay angles (else inactive).
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "qg";}
+  virtual int    resonanceA() const {return idRes;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idq, idRes, codeSave;
+  string nameSave;
+  double mRes, GammaRes, m2Res, GamMRat, Lambda, coupFcol, widthIn, sigBW;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* qStarPtr;
+
+};
+//**************************************************************************
+
+// A derived class for l gamma -> q^* (excited lepton state).
+
+class Sigma1lgm2lStar : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1lgm2lStar(int idlIn) : idl(idlIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for l* decay angles (else inactive).
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "fgm";}
+  virtual int    resonanceA() const {return idRes;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idl, idRes, codeSave;
+  string nameSave;
+  double mRes, GammaRes, m2Res, GamMRat, Lambda, coupChg, widthIn, sigBW;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* qStarPtr;
+
+};
+//**************************************************************************
+
+// A derived class for q q' -> q^* q' (excited quark state).
+
+class Sigma2qq2qStarq : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qq2qStarq(int idqIn) : idq(idqIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "qq";}
+  virtual int    id3Mass()    const {return idRes;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idq, idRes, codeSave;
+  string nameSave;
+  double Lambda, preFac, openFracPos, openFracNeg, sigmaA, sigmaB;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> l^* lbar (excited lepton state).
+
+class Sigma2qqbar2lStarlbar : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2lStarlbar(int idlIn) : idl(idlIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "qqbarSame";}
+  virtual int    id3Mass()    const {return idRes;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idl, idRes, codeSave;
+  string nameSave;
+  double Lambda, preFac, openFracPos, openFracNeg, sigma;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaCompositeness_H
diff --git a/PYTHIA8/pythia8130/include/SigmaEW.h b/PYTHIA8/pythia8130/include/SigmaEW.h
new file mode 100644 (file)
index 0000000..c816c14
--- /dev/null
@@ -0,0 +1,1019 @@
+// SigmaEW.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 electroweak process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma(1/2)Process.
+
+#ifndef Pythia8_SigmaEW_H
+#define Pythia8_SigmaEW_H
+
+#include "PythiaComplex.h"
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+
+//**************************************************************************
+
+// A derived class for q g -> q gamma (q = u, d, s, c, b).
+// Use massless approximation also for Q since no alternative.
+
+class Sigma2qg2qgamma : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2qgamma() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "q g -> q gamma (udscb)";}
+  virtual int    code()   const {return 201;}
+  virtual string inFlux() const {return "qg";}
+
+private:
+
+  // Values stored for later use.
+  double mNew, m2New, sigUS, sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> g gamma.
+
+class Sigma2qqbar2ggamma : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2ggamma() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "q qbar -> g gamma";}
+  virtual int    code()   const {return 202;}
+  virtual string inFlux() const {return "qqbarSame";}
+
+private:
+
+  // Values stored for later use.
+  double sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> g gamma.
+
+class Sigma2gg2ggamma : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2ggamma() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "g g -> g gamma";}
+  virtual int    code()   const {return 203;}
+  virtual string inFlux() const {return "gg";}
+
+private:
+
+  // Values stored for later use.  
+  double chargeSum, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> gamma gamma.
+
+class Sigma2ffbar2gammagamma : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2gammagamma() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "f fbar -> gamma gamma";}
+  virtual int    code()   const {return 204;}
+  virtual string inFlux() const {return "ffbarSame";}
+
+private:
+
+  // Values stored for later use.
+  double sigTU, sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> gamma gamma.
+
+class Sigma2gg2gammagamma : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2gammagamma() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "g g -> gamma gamma";}
+  virtual int    code()   const {return 205;}
+  virtual string inFlux() const {return "gg";}
+
+private:
+  
+  double charge2Sum, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange.
+
+class Sigma2ff2fftgmZ : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ff2fftgmZ() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "f f' -> f f' (t-channel gamma*/Z0)";}
+  virtual int    code()   const {return 211;}
+  virtual string inFlux() const {return "ff";}
+
+private:
+
+  //  Z parameters for propagator.
+  int    gmZmode;
+  double mZ, mZS, thetaWRat, sigmagmgm, sigmagmZ, sigmaZZ;
+
+};
+//**************************************************************************
+
+// A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
+
+class Sigma2ff2fftW : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ff2fftW() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()   const {return "f_1 f_2 -> f_3 f_4 (t-channel W+-)";}
+  virtual int    code()   const {return 212;}
+  virtual string inFlux() const {return "ff";}
+
+private:
+
+  //  W parameters for propagator.
+  double mW, mWS, thetaWRat, sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for q q' -> Q q" via t-channel W+- exchange.
+// Related to Sigma2ff2fftW class, but with massive matrix elements.
+
+class Sigma2qq2QqtW : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qq2QqtW(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angles in top decay (else inactive).
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ff";}
+  virtual int    id3Mass() const {return idNew;}
+
+private:
+
+  // Values stored for process type. W parameters for propagator.
+  int    idNew, codeSave;
+  string nameSave;
+  double mW, mWS, thetaWRat, sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> gamma*/Z0.
+
+class Sigma1ffbar2gmZ : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2gmZ() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for Z decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar -> gamma*/Z0";}
+  virtual int    code()       const {return 221;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    resonanceA() const {return 23;}
+
+private:
+
+  // Parameters set at initialization or for each new event. 
+  int    gmZmode;
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, 
+         gamSum, intSum, resSum, gamProp, intProp, resProp;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> W+-.
+
+class Sigma1ffbar2W : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2W() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> W+-";}
+  virtual int    code()       const {return 222;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual int    resonanceA() const {return 24;}
+
+private:
+
+  // Parameters set at initialization. 
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+
+//**************************************************************************
+
+// A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
+// Allows pT-ordered evolution for multiple interactions.
+
+class Sigma2ffbar2ffbarsgm : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2ffbarsgm() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()       const {
+    return "f fbar -> f' fbar' (s-channel gamma*)";}
+  virtual int    code()       const {return 223;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual bool   isSChannel() const {return true;}
+
+private:
+
+  // Values stored for later use.
+  int    idNew;
+  double sigma0;
+
+};
+
+//**************************************************************************
+
+// A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
+// Allows pT cuts as for other 2 -> 2 processes.
+
+class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn), 
+    codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angles in top decay (else inactive).
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual bool   isSChannel() const {return true;}
+  virtual int    id3Mass()    const {return idNew;}
+  virtual int    id4Mass()    const {return idNew;}
+  virtual int    resonanceA() const {return 23;}
+
+private:
+
+  // Values stored for process type. Z parameters for propagator.
+  int    idNew, codeSave, gmZmode;
+  string nameSave;
+  bool   isPhysical;
+  double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
+         mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair; 
+
+};
+
+//**************************************************************************
+
+// A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
+// Allows pT cuts as for other 2 -> 2 processes.
+
+class Sigma2ffbar2FfbarsW : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn), 
+    idNew2(idIn2), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angles in top decay (else inactive).
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual bool   isSChannel() const {return true;}
+  virtual int    id3Mass()    const {return idNew;}
+  virtual int    id4Mass()    const {return idPartner;}
+  virtual int    resonanceA() const {return 24;}
+
+private:
+
+  // Values stored for process type. W parameters for propagator.
+  int    idNew, idNew2, codeSave, idPartner;
+  string nameSave;
+  bool   isPhysical;
+  double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
+         openFracPos, openFracNeg; 
+
+};
+//**************************************************************************
+
+// An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
+
+class Sigma2ffbargmZWgmZW : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbargmZWgmZW() {}
+
+protected:
+
+  // Internal products. 
+  Vec4    pRot[7];
+  complex hA[7][7];
+  complex hC[7][7];
+
+  // Calculate and store internal products.
+  void setupProd( Event& process, int i1, int i2, int i3, int i4, 
+    int i5, int i6);   
+
+  // Evaluate the F function of Gunion and Kunszt.
+  complex fGK(int i1, int i2, int i3, int i4, int i5, int i6); 
+
+  // Evaluate the Xi function of Gunion and Kunszt.
+  double xiGK( double tHnow, double uHnow);
+
+  // Evaluate the Xj function of Gunion and Kunszt.
+  double xjGK( double tHnow, double uHnow);
+
+private:
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
+
+class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2gmZgmZ() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for simultaneous flavour choices.
+  virtual double weightDecayFlav( Event& process); 
+
+  // Evaluate weight for decay angles of the two gamma*/Z0.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
+  virtual int    code()    const {return 231;}
+  virtual string inFlux()  const {return "ffbarSame";}
+  virtual int    id3Mass() const {return 23;}
+  virtual int    id4Mass() const {return 23;}
+
+private:
+
+  // Parameters set at initialization or for each new event. 
+  int    gmZmode, i1, i2, i3, i4, i5, i6;
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,  
+         gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
+         gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
+         c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
+
+class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2ZW() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for Z0 and W+- decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> Z0 W+- (no gamma*!)";}
+  virtual int    code()       const {return 232;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual int    id3Mass()    const {return 23;}
+  virtual int    id4Mass()    const {return 24;}
+  virtual int    resonanceA() const {return 24;}
+
+private:
+
+  // Store W+- mass and width, and couplings.
+  double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat, 
+         thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> W+ W-.
+
+class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2WW() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W+ and W- decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar -> W+ W-";}
+  virtual int    code()       const {return 233;}
+  virtual int    id3Mass()    const {return 24;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    id4Mass()    const {return -24;}
+  virtual int    resonanceA() const {return 23;}
+
+private:
+
+  // Store Z0 mass and width.
+  double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg, 
+    cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
+
+};
+//**************************************************************************
+
+// An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
+
+class Sigma2ffbargmZggm : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbargmZggm() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Evaluate weight for gamma&/Z0 decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+protected:
+
+  // Parameters set at initialization or for each new event. 
+  int    gmZmode;
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, 
+         gamSum, intSum, resSum, gamProp, intProp, resProp;
+
+  // Evaluate current sum of flavour couplings times phase space. 
+  void flavSum(); 
+
+  // Evaluate current propagator terms of cross section. 
+  void propTerm(); 
+
+private:
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> gamma*/Z0 g.
+
+class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2gmZg() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q qbar -> gamma*/Z0 g";}
+  virtual int    code()    const {return 241;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return 23;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> gamma*/Z0 q.
+
+class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
+
+public:
+
+  // Constructor.
+  Sigma2qg2gmZq() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q g-> gamma*/Z0 q";}
+  virtual int    code()    const {return 242;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return 23;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> gamma*/Z0 gamma.
+
+class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2gmZgm() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f fbar -> gamma*/Z0 gamma";}
+  virtual int    code()    const {return 243;}
+  virtual string inFlux()  const {return "ffbarSame";}
+  virtual int    id3Mass() const {return 23;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for f gamma -> gamma*/Z0 f.
+
+class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
+
+public:
+
+  // Constructor.
+  Sigma2fgm2gmZf() {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f gamma -> gamma*/Z0 f";}
+  virtual int    code()    const {return 244;}
+  virtual string inFlux()  const {return "fgm";}
+  virtual int    id3Mass() const {return 23;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0;
+
+};
+//**************************************************************************
+
+// An intermediate class for f fbar -> W+- g/gamma and permutations.
+
+class Sigma2ffbarWggm : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbarWggm() {}
+
+  // Evaluate weight for gamma&/Z0 decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+private:
+
+};
+//**************************************************************************
+
+// A derived class for q qbar' -> W+- g.
+
+class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2Wg() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q qbar' -> W+- g";}
+  virtual int    code()    const {return 251;}
+  virtual string inFlux()  const {return "ffbarChg";}
+  virtual int    id3Mass() const {return 24;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> W+- q'.
+
+class Sigma2qg2Wq : public Sigma2ffbarWggm {
+
+public:
+
+  // Constructor.
+  Sigma2qg2Wq() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q g-> W+- q'";}
+  virtual int    code()    const {return 252;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return 24;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> W+- gamma.
+
+class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2Wgm() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f fbar' -> W+- gamma";}
+  virtual int    code()    const {return 253;}
+  virtual string inFlux()  const {return "ffbarChg";}
+  virtual int    id3Mass() const {return 24;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f gamma -> W+- f'.
+
+class Sigma2fgm2Wf : public Sigma2ffbarWggm {
+
+public:
+
+  // Constructor.
+  Sigma2fgm2Wf() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f gamma -> W+- f'";}
+  virtual int    code()    const {return 254;}
+  virtual string inFlux()  const {return "fgm";}
+  virtual int    id3Mass() const {return 24;}
+
+private:
+
+  // Values stored for later use.
+  double sigma0, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaEW_H
diff --git a/PYTHIA8/pythia8130/include/SigmaExtraDim.h b/PYTHIA8/pythia8130/include/SigmaExtraDim.h
new file mode 100644 (file)
index 0000000..df210df
--- /dev/null
@@ -0,0 +1,226 @@
+// SigmaExtraDim.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 extra-dimensional-process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma(1/2)Process.
+
+#ifndef Pythia8_SigmaExtraDim_H
+#define Pythia8_SigmaExtraDim_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for g g -> G^* (excited graviton state).
+
+class Sigma1gg2GravitonStar : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1gg2GravitonStar() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for G* decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "g g -> G*";}
+  virtual int    code()       const {return 5001;}
+  virtual string inFlux()     const {return "gg";}
+  virtual int    resonanceA() const {return idGstar;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idGstar;
+  double mRes, GammaRes, m2Res, GamMRat, kappaMG, sigma;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* gStarPtr;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> G^* (excited graviton state).
+
+class Sigma1ffbar2GravitonStar : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2GravitonStar() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return (abs(id1) < 9) ? sigma0 / 3. : sigma0;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for G* decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar -> G*";}
+  virtual int    code()       const {return 5002;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    resonanceA() const {return idGstar;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idGstar;
+  double mRes, GammaRes, m2Res, GamMRat, kappaMG, sigma0;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* gStarPtr;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> G^* g (excited graviton state).
+
+class Sigma2gg2GravitonStarg : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2GravitonStarg() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight: currently isotropic (except secondary top decay)..
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "g g -> G* g";}
+  virtual int    code()    const {return 5003;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idGstar;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idGstar;
+  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> G^* q (excited graviton state).
+
+class Sigma2qg2GravitonStarq : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2GravitonStarq() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight: currently isotropic (except secondary top decay)..
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q g -> G* q";}
+  virtual int    code()    const {return 5004;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return idGstar;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idGstar;
+  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> G^* g (excited graviton state).
+
+class Sigma2qqbar2GravitonStarg : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2GravitonStarg() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight: currently isotropic (except secondary top decay)..
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q qbar -> G* g";}
+  virtual int    code()    const {return 5005;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return idGstar;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idGstar;
+  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaExtraDim_H
diff --git a/PYTHIA8/pythia8130/include/SigmaHiggs.h b/PYTHIA8/pythia8130/include/SigmaHiggs.h
new file mode 100644 (file)
index 0000000..444fc82
--- /dev/null
@@ -0,0 +1,812 @@
+// SigmaHiggs.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 Torbjorn Sjostrand.
+// Part of code written by Marc Montull, CERN summer student 2007.
+// 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 Higgs process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma2Process.
+
+#ifndef Pythia8_SigmaHiggs_H
+#define Pythia8_SigmaHiggs_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for f fbar -> H0 (SM), H1, H2 or A3 (BSM).
+
+class Sigma1ffbar2H : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2H(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    resonanceA() const {return idRes;}
+
+private:
+
+  // An H0, H1, H2 or A3 resonance object provides coupling
+  // and propagator expressions.
+  ParticleDataEntry* HResPtr;
+  double mRes, GammaRes, m2Res, GamMRat, sigBW, widthOut;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for g g -> H0 (SM), H1, H2 or A3 (BSM).
+
+class Sigma1gg2H : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1gg2H(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave ;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "gg";} 
+  virtual int    resonanceA() const {return idRes;} 
+
+private:
+
+  // A H0, H1, H2 or A3 resonance object provides coupling 
+  // and propagator expressions.
+  ParticleDataEntry* HResPtr;
+  double mRes, GammaRes, m2Res, GamMRat, sigma;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for gamma gamma -> H0 (SM Higgs), H1, H2 or A3 (BSM Higgs).
+
+class Sigma1gmgm2H : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1gmgm2H(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;} 
+  virtual int    code()       const {return codeSave;} 
+  virtual string inFlux()     const {return "gmgm";} 
+  virtual int    resonanceA() const {return idRes;}
+
+private:
+
+  // A H0, H1, H2 or A3 resonance object provides coupling
+  // and propagator expressions.
+  ParticleDataEntry* HResPtr;
+  double mRes, GammaRes, m2Res, GamMRat, sigma;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for f fbar -> H Z0.
+// (H can be H0 SM or H1, H2, A3 from BSM).
+class Sigma2ffbar2HZ : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2HZ(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;} 
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual bool   isSChannel() const {return true;}
+  virtual int    id3Mass()    const {return idRes;}
+  virtual int    id4Mass()    const {return 23;}
+  virtual int    resonanceA() const {return 23;}
+  virtual int    gmZmode()    const {return 2;}
+
+private:
+
+  // Store Z0 mass and width.
+  double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, openFracPair, coup2Z;
+  int    higgsType, codeSave, idRes;  
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for f fbar -> H W+- (Standard Model Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma2ffbar2HW : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2HW(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual bool   isSChannel() const {return true;}
+  virtual int    id3Mass()    const {return idRes;}
+  virtual int    id4Mass()    const {return 24;}
+  virtual int    resonanceA() const {return 24;}
+
+private:
+
+  // Store W+- mass and width, and couplings.
+  double mW, widW, mWS, mwWS, thetaWRat, sigma0, openFracPairPos, 
+         openFracPairNeg, coup2W;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for f f' -> H f f' (Z0 Z0 fusion of SM or BSM Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma3ff2HfftZZ : public Sigma3Process {
+
+public:
+
+  // Constructor.
+  Sigma3ff2HfftZZ(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ff";}
+  virtual int    id3Mass() const {return idRes;}
+
+  // Instructions for 3-body phase space with t-channel propagators.
+  virtual int    idTchan1()        const {return 23;}
+  virtual int    idTchan2()        const {return 23;}
+  virtual double tChanFracPow1()   const {return 0.05;}
+  virtual double tChanFracPow2()   const {return 0.9;}
+  virtual bool   useMirrorWeight() const {return true;}
+
+private:
+
+  // Store standard factors.
+  double mZS, prefac, sigma1, sigma2, openFrac, coup2Z;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for f_1 f_2 -> H f_3 f_4 (W+ W- fusion of SM or BSM Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma3ff2HfftWW : public Sigma3Process {
+
+public:
+
+  // Constructor.
+  Sigma3ff2HfftWW(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ff";}
+  virtual int    id3Mass() const {return idRes;}
+
+  // Instructions for 3-body phase space with t-channel propagators.
+  virtual int    idTchan1()        const {return 24;}
+  virtual int    idTchan2()        const {return 24;}
+  virtual double tChanFracPow1()   const {return 0.05;}
+  virtual double tChanFracPow2()   const {return 0.9;}
+  virtual bool   useMirrorWeight() const {return true;}
+
+private:
+
+  // Store standard prefactor.
+  double mWS, prefac, sigma0, openFrac, coup2W;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for g g -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma3gg2HQQbar : public Sigma3Process {
+
+public:
+
+  // Constructor.
+  Sigma3gg2HQQbar(int idIn, int higgsTypeIn) : idNew(idIn),
+    higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idRes;}
+  virtual int    id4Mass() const {return idNew;}
+  virtual int    id5Mass() const {return idNew;}
+
+  // Instructions for 3-body phase space with t-channel propagators.
+  virtual int    idTchan1()        const {return idNew;}
+  virtual int    idTchan2()        const {return idNew;}
+  virtual double tChanFracPow1()   const {return 0.4;}
+  virtual double tChanFracPow2()   const {return 0.2;}
+  virtual bool   useMirrorWeight() const {return false;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  double prefac, sigma, openFracTriplet, coup2Q;
+  int    idNew, higgsType, codeSave, idRes;
+  string nameSave;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma3qqbar2HQQbar : public Sigma3Process {
+
+public:
+
+  // Constructor.
+  Sigma3qqbar2HQQbar(int idIn, int higgsTypeIn) : idNew(idIn), 
+    higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return idRes;}
+  virtual int    id4Mass() const {return idNew;}
+  virtual int    id5Mass() const {return idNew;}
+
+  // Instructions for 3-body phase space with t-channel propagators.
+  virtual int    idTchan1()        const {return idNew;}
+  virtual int    idTchan2()        const {return idNew;}
+  virtual double tChanFracPow1()   const {return 0.4;}
+  virtual double tChanFracPow2()   const {return 0.2;}
+  virtual bool   useMirrorWeight() const {return false;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  double prefac, sigma, openFracTriplet, coup2Q;
+  int    idNew, higgsType, codeSave, idRes;
+  string nameSave;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> H q (SM or BSM Higgs).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma2qg2Hq : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2Hq(int idIn, int higgsTypeIn) : idNew(idIn), 
+    higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return idRes;}
+  virtual int    id4Mass() const {return idNew;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  double m2W, thetaWRat, sigma, openFrac;
+  int    idNew, higgsType, codeSave, idRes;
+  string nameSave;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> H0 g (SM or BSM Higgs via heavy top loop).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma2gg2Hglt : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2Hglt(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idRes;}
+
+private:
+
+  // Store standard prefactor.
+  double widHgg, sigma, openFrac;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for q g -> H q (SM or BSM Higgs via heavy top loop).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma2qg2Hqlt : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2Hqlt(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return idRes;}
+
+private:
+
+  // Store standard prefactor.
+  double widHgg, sigma, openFrac;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for q qbar -> H g (SM or BSM Higgs via heavy top loop).
+// (H can be H0 SM or H1, H2, A3 from BSM).
+
+class Sigma2qqbar2Hglt : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2Hglt(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return idRes;}
+
+private:
+
+  // Store standard prefactor.
+  double widHgg, sigma, openFrac;
+  int    higgsType, codeSave, idRes;
+  string nameSave;
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> H+-.
+
+class Sigma1ffbar2Hchg : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2Hchg() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> H+-";}
+  virtual int    code()       const {return 961;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual int    resonanceA() const {return 37;}
+
+private:
+
+  // A H0 resonance object provides coupling and propagator expressions.
+  ParticleDataEntry* HResPtr;
+  double mRes, GammaRes, m2Res, GamMRat, m2W, thetaWRat, tan2Beta, sigBW, 
+         widthOutPos, widthOutNeg;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> H+- q'.
+
+class Sigma2qg2Hchgq : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2Hchgq(int idIn, int codeIn, string nameIn) : idNew(idIn), 
+    codeSave(codeIn), nameSave(nameIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return 37;}
+  virtual int    id4Mass() const {return idNew;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  int    idNew, codeSave, idOld, idUp, idDn;
+  string nameSave;
+  double m2W, thetaWRat, tan2Beta, sigma, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> A0(H_3) h0(H_1) or A0(H_3) H0(H_2).
+
+class Sigma2ffbar2A3H12 : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2A3H12(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ffbarSame";}
+  virtual int    id3Mass() const {return 36;}
+  virtual int    id4Mass() const {return higgs12;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  int    higgsType, higgs12, codeSave;
+  string nameSave;
+  double coupZA3H12, m2Z, mGammaZ, thetaWRat, openFrac, sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> H+- h0(H_1) or H+- H0(H_2).
+
+class Sigma2ffbar2HchgH12 : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2HchgH12(int higgsTypeIn) : higgsType(higgsTypeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ffbarChg";}
+  virtual int    id3Mass() const {return 37;}
+  virtual int    id4Mass() const {return higgs12;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  int    higgsType, higgs12, codeSave;
+  string nameSave;
+  double coupWHchgH12, m2W, mGammaW, thetaWRat, openFracPos, openFracNeg,
+         sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> H+ H-.
+
+class Sigma2ffbar2HposHneg : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2HposHneg() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "f fbar -> H+ H-";}
+  virtual int    code()    const {return 1085;}
+  virtual string inFlux()  const {return "ffbarSame";}
+  virtual int    id3Mass() const {return 37;}
+  virtual int    id4Mass() const {return 37;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  double m2Z, mGammaZ, thetaWRat, eH, lH, openFrac, gamSig, intSig, resSig;
+
+};
+  
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaHiggs_H
diff --git a/PYTHIA8/pythia8130/include/SigmaLeftRightSym.h b/PYTHIA8/pythia8130/include/SigmaLeftRightSym.h
new file mode 100644 (file)
index 0000000..13ff8df
--- /dev/null
@@ -0,0 +1,275 @@
+// SigmaLeftRightSym.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 left-rights-symmetry differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma(1/2/3)Process.
+
+#ifndef Pythia8_SigmaLeftRightSym_H
+#define Pythia8_SigmaLeftRightSym_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for f fbar -> Z_R^0 (righthanded gauge boson).
+
+class Sigma1ffbar2ZRight : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2ZRight() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat(); 
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for G* decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar -> Z_R^0";}
+  virtual int    code()       const {return 3101;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    resonanceA() const {return idZR;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idZR;
+  double mRes, GammaRes, m2Res, GamMRat, sin2tW, sigma0;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* ZRPtr;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> W_R^+- (righthanded gauge boson).
+
+class Sigma1ffbar2WRight : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2WRight() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> W_R^+-";}
+  virtual int    code()       const {return 3102;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual int    resonanceA() const {return idWR;}
+
+private:
+
+  // Parameters set at initialization. 
+  int    idWR;
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+// A derived class for l l -> H_L^++-- or H_R^++-- (doubly charged Higgs).
+
+class Sigma1ll2Hchgchg : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ll2Hchgchg(int leftRightIn ) : leftRight(leftRightIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ff";}
+  virtual int    resonanceA() const {return idHLR;}
+
+private:
+
+  // Parameters set at initialization. 
+  int    leftRight, idHLR, codeSave;
+  string nameSave;
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, yukawa[4][4];
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+}; 
+//**************************************************************************
+
+// A derived class for l- gamma -> H_(L/R)^-- l+  (doubly charged Higgs).
+
+class Sigma2lgm2Hchgchgl : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2lgm2Hchgchgl(int leftRightIn, int idLepIn ) : leftRight(leftRightIn),
+    idLep(idLepIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "fgm";}
+  virtual int    resonanceA() const {return idHLR;}
+
+private:
+
+  // Parameters set at initialization. 
+  int    leftRight, idHLR, idLep, codeSave;
+  string nameSave;
+  double yukawa[4], openFracPos, openFracNeg;
+
+}; 
+//**************************************************************************
+
+// A derived class for f_1 f_2 -> H_(L/R)^++-- f_3 f_4 (W+- W+- fusion).
+
+class Sigma3ff2HchgchgfftWW : public Sigma3Process {
+
+public:
+
+  // Constructor.
+  Sigma3ff2HchgchgfftWW(int leftRightIn) : leftRight(leftRightIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "ff";}
+  virtual int    id3Mass() const {return idHLR;}
+
+  // Instructions for 3-body phase space with t-channel propagators.
+  virtual int    idTchan1()        const {return 9900024;}
+  virtual int    idTchan2()        const {return 9900024;}
+  virtual double tChanFracPow1()   const {return 0.05;}
+  virtual double tChanFracPow2()   const {return 0.9;}
+  virtual bool   useMirrorWeight() const {return true;}
+
+private:
+
+  // Store standard prefactor.
+  int    leftRight, idHLR, codeSave;
+  string nameSave;
+  double mWS, prefac, sigma0TU, sigma0T, openFracPos, openFracNeg;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> H_(L/R)^++ H_(L/R)^--  (doubly charged Higgs).
+
+class Sigma2ffbar2HchgchgHchgchg : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2ffbar2HchgchgHchgchg(int leftRightIn) : leftRight(leftRightIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return nameSave;}
+  virtual int    code()       const {return codeSave;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    id3Mass()    const {return idHLR;}
+  virtual int    id4Mass()    const {return idHLR;}
+  virtual int    resonanceA() const {return 23;}
+
+private:
+
+  // Parameters set at initialization. 
+  int    leftRight, idHLR, codeSave;
+  string nameSave;
+  double mRes, GammaRes, m2Res, GamMRat, sin2tW, preFac, yukawa[4][4], 
+         openFrac;
+
+}; 
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaLeftRightSym_H
diff --git a/PYTHIA8/pythia8130/include/SigmaLeptoquark.h b/PYTHIA8/pythia8130/include/SigmaLeptoquark.h
new file mode 100644 (file)
index 0000000..2a1c39b
--- /dev/null
@@ -0,0 +1,176 @@
+// SigmaLeptoquark.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 leptoquark-process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma(1/2)Process.
+// Note: since leptoquark assumed scalar no need for decay-angles routines.
+
+#ifndef Pythia8_SigmaLeptoquark_H
+#define Pythia8_SigmaLeptoquark_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for q l -> LQ (leptoquark).
+
+class Sigma1ql2LeptoQuark : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ql2LeptoQuark() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()       const {return "q l -> LQ (leptoquark)";}
+  virtual int    code()       const {return 3201;}
+  virtual string inFlux()     const {return "ff";}
+  virtual int    resonanceA() const {return 42;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idQuark, idLepton;
+  double mRes, GammaRes, m2Res, GamMRat, kCoup, widthIn, sigBW;
+
+  // Pointer to properties of the particle species, to access decay channel.
+  ParticleDataEntry* LQPtr;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> LQ l (leptoquark).
+
+class Sigma2qg2LeptoQuarkl : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2LeptoQuarkl() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q g -> LQ l (leptoquark)";}
+  virtual int    code()    const {return 3202;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return 42;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idQuark, idLepton;
+  double mRes, GammaRes, m2Res, GamMRat, kCoup, openFracPos, openFracNeg,
+         sigma0;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> LQ LQbar (leptoquark).
+
+class Sigma2gg2LQLQbar : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2LQLQbar() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "g g -> LQ LQbar (leptoquark)";}
+  virtual int    code()    const {return 3203;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return 42;}
+  virtual int    id4Mass() const {return 42;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  double mRes, GammaRes, m2Res, GamMRat, openFrac, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> LQ LQbar (leptoquark).
+
+class Sigma2qqbar2LQLQbar : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2LQLQbar() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat() {
+    return (abs(id1) == idQuark) ? sigmaSame : sigmaDiff;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return "q qbar -> LQ LQbar (leptoquark)";}
+  virtual int    code()    const {return 3204;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return 42;}
+  virtual int    id4Mass() const {return 42;}
+
+private:
+
+  // Parameters set at initialization or for current kinematics. 
+  int    idQuark;
+  double mRes, GammaRes, m2Res, GamMRat, kCoup, openFrac, sigmaDiff, 
+         sigmaSame;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaLeptoquark_H
diff --git a/PYTHIA8/pythia8130/include/SigmaNewGaugeBosons.h b/PYTHIA8/pythia8130/include/SigmaNewGaugeBosons.h
new file mode 100644 (file)
index 0000000..b8a0248
--- /dev/null
@@ -0,0 +1,185 @@
+// SigmaNewGaugeBosons.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 new-gauge-boson-process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma1Process.
+
+#ifndef Pythia8_SigmaNewGaugeBosons_H
+#define Pythia8_SigmaNewGaugeBosons_H
+
+#include "PythiaComplex.h"
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// An intermediate class for f fbar -> Z'/W' -> WW/WZ -> 4 fermions.
+// Copied from SigmaEW for gauge-boson-pair production.
+
+class Sigma1ffbarZprimeWprime: public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbarZprimeWprime() {}
+
+protected:
+
+  // Internal products. 
+  Vec4    pRot[7];
+  complex hA[7][7];
+  complex hC[7][7];
+
+  // Calculate and store internal products.
+  void setupProd( Event& process, int i1, int i2, int i3, int i4, 
+    int i5, int i6);   
+
+  // Evaluate the F function of Gunion and Kunszt.
+  complex fGK(int i1, int i2, int i3, int i4, int i5, int i6); 
+
+  // Evaluate the Xi function of Gunion and Kunszt.
+  double xiGK( double tHnow, double uHnow, double s3now, double s4now);
+
+  // Evaluate the Xj function of Gunion and Kunszt.
+  double xjGK( double tHnow, double uHnow, double s3now, double s4now);
+
+private:
+
+};
+//**************************************************************************
+
+// A derived class for f fbar -> gamma*/Z0/Z'0.
+
+class Sigma1ffbar2gmZZprime : public Sigma1ffbarZprimeWprime {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2gmZZprime() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for Z' decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar -> gamma*/Z0/Zprime0";}
+  virtual int    code()       const {return 3001;}
+  virtual string inFlux()     const {return "ffbarSame";}
+  virtual int    resonanceA() const {return 23;}
+  virtual int    resonanceB() const {return 32;}
+
+private:
+
+  // Parameters set at initialization or for each new event. 
+  int    gmZmode;
+  double mRes, GammaRes, m2Res, GamMRat, sin2tW, cos2tW, thetaWRat, 
+         mZ, GammaZ, m2Z, GamMRatZ, afZp[20], vfZp[20], coupZpWW,
+         anglesZpWW, gamSum, gamZSum, ZSum, gamZpSum, ZZpSum, ZpSum,
+         gamNorm, gamZNorm, ZNorm, gamZpNorm, ZZpNorm, ZpNorm;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+
+//**************************************************************************
+
+// A derived class for f fbar' -> W'+-.
+
+class Sigma1ffbar2Wprime : public Sigma1ffbarZprimeWprime {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2Wprime() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for W decay angle.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> W'+-";}
+  virtual int    code()       const {return 3021;}
+  virtual string inFlux()     const {return "ffbarChg";}
+  virtual int    resonanceA() const {return 34;}
+
+private:
+
+  // Parameters set at initialization. 
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg,
+         aqWp, vqWp, alWp, vlWp, coupWpWZ, anglesWpWZ;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+// A derived class for f fbar' -> R^0 (horizontal gauge boson).
+
+class Sigma1ffbar2Rhorizontal : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1ffbar2Rhorizontal() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()       const {return "f fbar' -> R^0";}
+  virtual int    code()       const {return 3041;}
+  virtual string inFlux()     const {return "ffbar";}
+  virtual int    resonanceA() const {return 41;}
+
+private:
+
+  // Parameters set at initialization. 
+  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
+
+  // Pointer to properties of the particle species, to access decay channels.
+  ParticleDataEntry* particlePtr;
+
+};
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia_SigmaNewGaugeBosons_H
diff --git a/PYTHIA8/pythia8130/include/SigmaOnia.h b/PYTHIA8/pythia8130/include/SigmaOnia.h
new file mode 100644 (file)
index 0000000..3f5ee6e
--- /dev/null
@@ -0,0 +1,294 @@
+// SigmaOnia.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 charmonia/bottomonia process differential cross sections.
+// Contains classes derived from SigmaProcess via Sigma2Process.
+
+#ifndef Pythia8_SigmaOnia_H
+#define Pythia8_SigmaOnia_H
+
+#include "SigmaProcess.h"
+
+namespace Pythia8 {
+//**************************************************************************
+
+// A derived class for g g -> QQbar[3S1(1)] g (Q = c or b).
+
+class Sigma2gg2QQbar3S11g : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2QQbar3S11g(int idIn, int codeIn) : idNew(idIn), 
+    codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
+
+class Sigma2gg2QQbar3PJ1g : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2QQbar3PJ1g(int idIn, int jIn, int codeIn) : idNew(idIn), 
+    jSave(jIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, jSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> QQbar[3PJ(1)] q (Q = c or b, J = 0, 1 or 2).
+
+class Sigma2qg2QQbar3PJ1q : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2QQbar3PJ1q(int idIn, int jIn, int codeIn) : idNew(idIn), 
+    jSave(jIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, jSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
+
+class Sigma2qqbar2QQbar3PJ1g : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2QQbar3PJ1g(int idIn, int jIn, int codeIn) : idNew(idIn), 
+    jSave(jIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, jSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for g g -> QQbar[X(8)] g (Q = c or b, X = 3S1, 1S0 or 3PJ).
+
+class Sigma2gg2QQbarX8g : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2gg2QQbarX8g(int idIn, int stateIn, int codeIn) : idNew(idIn), 
+    stateSave(stateIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "gg";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, stateSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q g -> QQbar[X(8)] q (Q = c or b, X = 3S1, 1S0 or 3PJ).
+
+class Sigma2qg2QQbarX8q : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qg2QQbarX8q(int idIn, int stateIn, int codeIn) : idNew(idIn), 
+    stateSave(stateIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, stateSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+//**************************************************************************
+
+// A derived class for q qbar -> QQbar[X(8)] g (Q = c or b, 
+//   X = 3S1, 1S0 or 3PJ).
+
+class Sigma2qqbar2QQbarX8g : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2qqbar2QQbarX8g(int idIn, int stateIn, int codeIn) : idNew(idIn), 
+    stateSave(stateIn), codeSave(codeIn) {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate d(sigmaHat)/d(tHat). 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Info on the subprocess.
+  virtual string name()    const {return nameSave;}
+  virtual int    code()    const {return codeSave;}
+  virtual string inFlux()  const {return "qqbarSame";}
+  virtual int    id3Mass() const {return idHad;}
+
+ private:
+
+  // Values stored for process type and colour flow selection.
+  int    idNew, idHad, stateSave, codeSave;
+  string nameSave;
+  double oniumME, sigma;
+
+};
+
+//**************************************************************************
+
+} // end namespace Pythia8
+
+#endif // Pythia8_SigmaOnia_H
diff --git a/PYTHIA8/pythia8130/include/SigmaProcess.h b/PYTHIA8/pythia8130/include/SigmaProcess.h
new file mode 100644 (file)
index 0000000..3fec34f
--- /dev/null
@@ -0,0 +1,537 @@
+// SigmaProcess.h is a part of the PYTHIA event generator.
+// Copyright (C) 2008 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 hard-process differential cross sections.
+// SigmaProcess: base class for cross sections.
+// Sigma0Process: base class for unresolved processes, derived from above.
+// Sigma1Process: base class for 2 -> 1 processes, derived from above.
+// Sigma2Process: base class for 2 -> 2 processes, derived from above.
+// Sigma3Process: base class for 2 -> 3 processes, derived from above.
+// SigmaLHAProcess: wrapper class for Les Houches Accord external input.
+// Actual physics processes are found in separate files:
+// SigmaQCD for QCD processes;
+// SigmaEW for electroweak processes (including photon production);
+// SigmaOnia for charmonium and bottomonium processes;
+// SigmaHiggs for Higgs processes;
+// SigmaSUSY for supersymmetric production;
+// SigmaLeftRightSym for  processes in left-right-symmetric scenarios;
+// SigmaLeptoquark for leptoquark production.
+// SigmaExtraDim for processes in scenarios for extra dimensions.
+
+#ifndef Pythia8_SigmaProcess_H
+#define Pythia8_SigmaProcess_H
+
+#include "Basics.h"
+#include "BeamParticle.h"
+#include "Event.h"
+#include "Info.h"
+#include "LesHouches.h"
+#include "ParticleData.h"
+#include "PartonDistributions.h"
+#include "PythiaStdlib.h"
+#include "ResonanceWidths.h"
+#include "Settings.h"
+#include "SigmaTotal.h"
+#include "StandardModel.h"
+#include "SusyLesHouches.h"
+
+namespace Pythia8 {
+
+//**************************************************************************
+
+// InBeam is a simple helper class for partons and their flux in a beam.
+
+class InBeam {
+
+public:
+
+  // Constructor.
+  InBeam( int idIn = 0) : id(idIn), pdf(0.) {}
+
+  // Values.
+  int    id;
+  double pdf;
+
+};
+
+//**************************************************************************
+
+// InPair is a simple helper class for colliding parton pairs and their flux.
+
+class InPair {
+
+public:
+
+  // Constructor.
+  InPair( int idAIn = 0, int idBIn = 0) : idA(idAIn), idB(idBIn),
+    pdfA(0.), pdfB(0.), pdfSigma(0.) {}
+
+  // Values.
+  int    idA, idB;
+  double pdfA, pdfB, pdfSigma;
+
+};
+//**************************************************************************
+
+// SigmaProcess is the base class for cross section calculations.
+
+class SigmaProcess {
+
+public:
+
+  // Destructor.
+  virtual ~SigmaProcess() {}
+
+  // Perform simple initialization and store pointers.
+  void init(Info* infoPtrIn, BeamParticle* beamAPtrIn, 
+    BeamParticle* beamBPtrIn, AlphaStrong* alphaSPtrIn, 
+    AlphaEM* alphaEMPtrIn, SigmaTotal* sigmaTotPtrIn,
+    SusyLesHouches* slhaPtrIn);
+
+  // Store or replace Les Houches pointer.
+  void setLHAPtr( LHAup* lhaUpPtrIn) {lhaUpPtr = lhaUpPtrIn;}  
+
+  // Initialize process. Only used for some processes.
+  virtual void initProc() {}
+
+  // Set up allowed flux of incoming partons. Default is no flux.
+  virtual bool initFlux();
+
+  // Input and complement kinematics for resolved 2 -> 1 process.
+  // Usage: set1Kin( x1in, x2in, sHin).
+  virtual void set1Kin( double , double , double ) {} 
+
+  // Input and complement kinematics for resolved 2 -> 2 process.
+  // Usage: set2Kin( x1in, x2in, sHin, tHin, m3in, m4in, runBW3in, runBW4in).
+  virtual void set2Kin( double , double , double , double , double , 
+    double, double, double ) {} 
+
+  // Ditto, but for Multiple Interactions applications, so different input.
+  // Usage: set2KinMI( x1in, x2in, sHin, tHin, uHin, 
+  //                   alpSin, alpEMin, needMasses, m3in, m4in)
+  virtual void set2KinMI( double , double , double , double , 
+    double , double , double , bool , double , double ) {}
+
+  // Input and complement kinematics for resolved 2 -> 3 process.
+  // Usage: set3Kin( x1in, x2in, sHin, p3prel, p4prel, p5prel, 
+  //                 m3in, m4in, m5in, runBW3in, runBW4in, runBW5in); 
+  virtual void set3Kin( double , double , double , Vec4 , Vec4 , Vec4 , 
+    double , double , double , double , double , double ) {}
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin() {}
+
+  // Evaluate sigma for unresolved, sigmaHat(sHat) for 2 -> 1 processes, 
+  // d(sigmaHat)/d(tHat) for (resolved) 2 -> 2 processes, and |M|^2 for 
+  // 2 -> 3 processes. Answer in "native" units, either mb or GeV^-2. 
+  virtual double sigmaHat() {return 0.;}
+
+  // Wrapper to sigmaHat, to (a) store current incoming flavours and 
+  // (b) convert from GeV^-2 to mb where required.
+  double sigmaHatWrap(int id1in = 0, int id2in = 0) {
+    id1 = id1in; id2 = id2in; 
+    return ( convert2mb() ? CONVERT2MB * sigmaHat() : sigmaHat() ); }
+
+  // Convolute above with parton flux and K factor. Sum over open channels. 
+  virtual double sigmaPDF();
+
+  // Select incoming parton channel and extract parton densities (resolved).
+  void pickInState(int id1in = 0, int id2in = 0);
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol() {}
+
+  // Perform kinematics for a Multiple Interaction, in its rest frame.
+  virtual bool final2KinMI() {return true;}
+
+  // Evaluate weight for simultaneous flavours (only gamma*/Z0 gamma*/Z0).
+  // Usage: weightDecayFlav( process).
+  virtual double weightDecayFlav( Event&) {return 1.;} 
+
+  // Evaluate weight for decay angular configuration.
+  // Usage: weightDecay( process, iResBeg, iResEnd), where 
+  // iResBeg <= i < iResEnd is range of sister partons to test decays of.
+  virtual double weightDecay( Event&, int, int) {return 1.;}
+
+  // Process name and code, and the number of final-state particles.
+  virtual string name()            const {return "unnamed process";}
+  virtual int    code()            const {return 0;}
+  virtual int    nFinal()          const {return 2;}
+
+  // Need to know which incoming partons to set up interaction for.
+  virtual string inFlux()          const {return "unknown";}
+
+  // Need to know whether to convert cross section answer from GeV^-2 to mb.
+  virtual bool   convert2mb()      const {return true;}
+
+  // Special treatment needed for Les Houches processes.
+  virtual bool   isLHA()           const {return false;}
+
+  // Special treatment needed for elastic and diffractive processes.
+  virtual bool   isMinBias()       const {return false;}
+  virtual bool   isResolved()      const {return true;}
+  virtual bool   isDiffA()         const {return false;}
+  virtual bool   isDiffB()         const {return false;}
+
+  // Special treatment needed if negative cross sections allowed.
+  virtual bool   allowNegativeSigma() const {return false;}
+
+  // Flavours in 2 -> 2/3 processes where masses needed from beginning. 
+  // (For a light quark masses will be used in the final kinematics,
+  // but not at the matrix-element level. For a gluon no masses at all.) 
+  virtual int    id3Mass()         const {return 0;}
+  virtual int    id4Mass()         const {return 0;}
+  virtual int    id5Mass()         const {return 0;}
+
+  // Special treatment needed if process contains an s-channel resonance.
+  virtual int    resonanceA()      const {return 0;}
+  virtual int    resonanceB()      const {return 0;}
+
+  // 2 -> 2 and 2 -> 3 processes only through s-channel exchange.
+  virtual bool isSChannel()        const {return false;}
+
+  // Special treatment in 2 -> 3 with two massive propagators.
+  virtual int    idTchan1()        const {return 0;}
+  virtual int    idTchan2()        const {return 0;}
+  virtual double tChanFracPow1()   const {return 0.3;}
+  virtual double tChanFracPow2()   const {return 0.3;}
+  virtual bool   useMirrorWeight() const {return false;}
+
+  // Special process-specific gamma*/Z0 choice if >=0 (e.g. f fbar -> H0 Z0).
+  virtual int    gmZmode()         const {return -1;}
+
+  // Tell whether tHat and uHat are swapped (= same as swap 3 and 4).
+  bool swappedTU()          const {return swapTU;}
+  
+  // Give back particle properties: flavours, colours, masses, or all.
+  int    id(int i)          const {return idSave[i];}
+  int    col(int i)         const {return colSave[i];} 
+  int    acol(int i)        const {return acolSave[i];}
+  double m(int i)           const {return mSave[i];}
+  Particle getParton(int i) const {return parton[i];}
+
+  // Give back couplings and parton densities. Not all known for minbias.
+  double Q2Ren()            const {return Q2RenSave;}
+  double alphaEMRen()       const {return alpEM;}
+  double alphaSRen()        const {return alpS;}
+  double Q2Fac()            const {return Q2FacSave;}
+  double pdf1()             const {return pdf1Save;}
+  double pdf2()             const {return pdf2Save;}
+
+  // Give back angles; relevant only for multipe-interactions processes.
+  double thetaMI()          const {return atan2( sinTheta, cosTheta);}
+  double phiMI()            const {return phi;}
+  double sHBetaMI()         const {return sHBeta;}
+  double pT2MI()            const {return pT2Mass;}
+
+protected:
+
+  // Constructor.
+  SigmaProcess() {for (int i = 0; i < 6; ++i) mSave[i] = 0.;}
+
+  // Constants: could only be changed in the code itself.
+  static const double CONVERT2MB, MASSMARGIN;
+
+  // Pointer to various information on the generation.
+  Info*           infoPtr;
+
+  // Pointers to incoming beams.
+  BeamParticle*   beamAPtr;
+  BeamParticle*   beamBPtr;
+
+  // Pointers to alphaStrong and alphaElectromagnetic calculation.
+  AlphaStrong*    alphaSPtr;
+  AlphaEM*        alphaEMPtr;
+  
+  // Pointer to the total/elastic/diffractive cross section object.
+  SigmaTotal*     sigmaTotPtr;
+
+  // Pointer to LHAup for generating external events.
+  LHAup*          lhaUpPtr;
+
+  // Pointer to the SLHA object.
+  SusyLesHouches* slhaPtr;
+
+  // Initialization data, normally only set once.
+  int    nQuarkIn, renormScale1, renormScale2, renormScale3, renormScale3VV, 
+         factorScale1, factorScale2, factorScale3, factorScale3VV;
+  double Kfactor, renormMultFac, renormFixScale, factorMultFac, 
+         factorFixScale;
+
+  // CP violation parameters for Higgs sector, normally only set once.
+  int    higgsH1parity, higgsH2parity, higgsA3parity;
+  double higgsH1eta, higgsH2eta, higgsA3eta;  
+
+  // Information on incoming beams.
+  int    idA, idB;
+  double mA, mB; 
+  bool   isLeptonA, isLeptonB, hasLeptonBeams;
+
+  // Partons in beams, with PDF's.
+  vector<InBeam> inBeamA;
+  vector<InBeam> inBeamB;
+  void addBeamA(int idIn) {inBeamA.push_back(InBeam(idIn));}
+  void addBeamB(int idIn) {inBeamB.push_back(InBeam(idIn));}
+  int sizeBeamA() const {return inBeamA.size();}
+  int sizeBeamB() const {return inBeamB.size();}
+  // Allowed colliding parton pairs, with pdf's.
+  vector<InPair> inPair;
+  void addPair(int idAIn, int idBIn) {
+    inPair.push_back(InPair(idAIn, idBIn));}
+  int sizePair() const {return inPair.size();}
+
+  // Store Q2 renormalization and factorization scales, and related values.
+  double Q2RenSave, alpEM, alpS, Q2FacSave, x1Save, x2Save, pdf1Save, 
+         pdf2Save, sigmaSumSave;
+
+  // Store flavour, colour, anticolour, mass, angles and the whole particle.
+  int      id1, id2, id3, id4, id5;
+  int      idSave[6], colSave[6], acolSave[6];
+  double   mSave[6], cosTheta, sinTheta, phi, sHMass, sHBeta, pT2Mass;
+  Particle parton[6];
+
+  // Store whether tHat and uHat are swapped (= same as swap 3 and 4).
+  bool swapTU;
+
+  // Set flavour, colour and anticolour.
+  void setId( int id1in = 0, int id2in = 0, int id3in = 0, int id4in = 0,
+    int id5in = 0) {idSave[1] = id1in; idSave[2] = id2in; idSave[3] = id3in; 
+    idSave[4] = id4in; idSave[5] = id5in;}
+  void setColAcol( int col1 = 0, int acol1 = 0, 
+    int col2 = 0, int acol2 = 0, int col3 = 0, int acol3 = 0, 
+    int col4 = 0, int acol4 = 0, int col5 = 0, int acol5 = 0) {
+    colSave[1] = col1; acolSave[1] = acol1; colSave[2] = col2; 
+    acolSave[2] = acol2; colSave[3] = col3; acolSave[3] = acol3; 
+    colSave[4] = col4; acolSave[4] = acol4; colSave[5] = col5; 
+    acolSave[5] = acol5; }
+  void swapColAcol() { swap(colSave[1], acolSave[1]); 
+    swap(colSave[2], acolSave[2]); swap(colSave[3], acolSave[3]); 
+    swap(colSave[4], acolSave[4]); swap(colSave[5], acolSave[5]);}
+  void swapCol1234() { swap(colSave[1], colSave[2]); 
+    swap(colSave[3], colSave[4]); swap(acolSave[1], acolSave[2]); 
+    swap(acolSave[3], acolSave[4]);}
+  void swapCol12() { swap(colSave[1], colSave[2]); 
+    swap(acolSave[1], acolSave[2]);}
+  void swapCol34() { swap(colSave[3], colSave[4]); 
+    swap(acolSave[3], acolSave[4]);}
+
+  // Common code for top and Higgs secondary decay angular weights.
+  double weightTopDecay( Event& process, int iResBeg, int iResEnd);
+  double weightHiggsDecay( Event& process, int iResBeg, int iResEnd);
+
+};
+//**************************************************************************
+
+// Sigma0Process is the base class for unresolved and minimum-bias processes. 
+// It is derived from SigmaProcess.
+
+class Sigma0Process : public SigmaProcess {
+
+public:
+
+  // Destructor.
+  virtual ~Sigma0Process() {}
+
+  // Number of final-state particles.
+  virtual int    nFinal() const {return 2;};
+
+  // No partonic flux to be set up.
+  virtual bool   initFlux() {return true;}
+
+  // Evaluate sigma for unresolved processes. 
+  virtual double sigmaHat() {return 0.;}
+
+  // Since no PDF's there is no difference from above. 
+  virtual double sigmaPDF() {return sigmaHat();}
+
+  // Answer for these processes already in mb, so do not convert.
+  virtual bool convert2mb() const {return false;}
+
+protected:
+
+  // Constructor.
+  Sigma0Process() {}
+
+};
+//**************************************************************************
+
+// Sigma1Process is the base class for 2 -> 1 processes.
+// It is derived from SigmaProcess.
+
+class Sigma1Process : public SigmaProcess {
+
+public:
+
+  // Destructor.
+  virtual ~Sigma1Process() {}
+
+  // Number of final-state particles.
+  virtual int    nFinal() const {return 1;};
+
+  // Input and complement kinematics for resolved 2 -> 1 process.
+  virtual void   set1Kin( double x1in, double x2in, double sHin) {
+    store1Kin( x1in, x2in, sHin); sigmaKin();} 
+
+  // Evaluate sigmaHat(sHat) for resolved 2 -> 1 processes. 
+  virtual double sigmaHat() {return 0.;}
+
+protected:
+
+  // Constructor.
+  Sigma1Process() {}
+
+  // Store kinematics and set scales for resolved 2 -> 1 process.
+  virtual void   store1Kin( double x1in, double x2in, double sHin);
+
+  // Store subprocess kinematics quantities.
+  double mH, sH, sH2;
+
+};
+//**************************************************************************
+
+// Sigma2Process is the base class for 2 -> 2 processes.
+// It is derived from SigmaProcess.
+
+class Sigma2Process : public SigmaProcess {
+
+public:
+
+  // Destructor.
+  virtual ~Sigma2Process() {}
+
+  // Number of final-state particles.
+  virtual int    nFinal() const {return 2;};
+
+  // Input and complement kinematics for resolved 2 -> 2 process.
+  virtual void   set2Kin( double x1in, double x2in, double sHin, 
+    double tHin, double m3in, double m4in, double runBW3in, 
+    double runBW4in) { store2Kin( x1in, x2in, sHin, tHin, m3in, m4in, 
+    runBW3in, runBW4in); sigmaKin();}
+
+  // Ditto, but for Multiple Interactions applications, so different input.
+  virtual void   set2KinMI( double x1in, double x2in, double sHin, 
+    double tHin, double uHin, double alpSin, double alpEMin, 
+    bool needMasses, double m3in, double m4in) {
+    store2KinMI( x1in, x2in, sHin, tHin, uHin, alpSin, alpEMin, 
+    needMasses, m3in, m4in); sigmaKin();}
+
+  // Evaluate d(sigmaHat)/d(tHat) for resolved 2 -> 2 processes. 
+  virtual double sigmaHat() {return 0.;}
+
+  // Perform kinematics for a Multiple Interaction, in its rest frame.
+  virtual bool   final2KinMI();
+
+protected:
+
+  // Constructor.
+  Sigma2Process() {}
+
+  // Store kinematics and set scales for resolved 2 -> 2 process.
+  virtual void   store2Kin( double x1in, double x2in, double sHin, 
+    double tHin, double m3in, double m4in, double runBW3in, 
+    double runBW4in);
+  virtual void   store2KinMI( double x1in, double x2in, double sHin, 
+    double tHin, double uHin, double alpSin, double alpEMin, 
+    bool needMasses, double m3in, double m4in);
+
+  // Store subprocess kinematics quantities.
+  double mH, sH, tH, uH, sH2, tH2, uH2, m3, s3, m4, s4, pT2, runBW3, runBW4;
+
+};
+//**************************************************************************
+
+// Sigma3Process is the base class for 2 -> 3 processes.
+// It is derived from SigmaProcess.
+
+class Sigma3Process : public SigmaProcess {
+
+public:
+
+  // Destructor.
+  virtual ~Sigma3Process() {}
+
+  // Number of final-state particles.
+  virtual int    nFinal() const {return 3;};
+
+  // Input and complement kinematics for resolved 2 -> 3 process.
+  virtual void   set3Kin( double x1in, double x2in, double sHin, 
+    Vec4 p3cmIn, Vec4 p4cmIn, Vec4 p5cmIn, double m3in, double m4in, 
+    double m5in, double runBW3in, double runBW4in, double runBW5in) { 
+    store3Kin( x1in, x2in, sHin, p3cmIn, p4cmIn, p5cmIn, m3in, m4in, m5in,
+    runBW3in, runBW4in, runBW5in); sigmaKin();}
+
+  // Evaluate d(sigmaHat)/d(tHat) for resolved 2 -> 3 processes. 
+  virtual double sigmaHat() {return 0.;}
+
+protected:
+
+  // Constructor.
+  Sigma3Process() {}
+
+  // Store kinematics and set scales for resolved 2 -> 3 process.
+  virtual void   store3Kin( double x1in, double x2in, double sHin, 
+    Vec4 p3cmIn, Vec4 p4cmIn, Vec4 p5cmIn, double m3in, double m4in, 
+    double m5in, double runBW3in, double runBW4in, double runBW5in);
+
+  // Store subprocess kinematics quantities.
+  double mH, sH, m3, s3,