Update to pythi8.170
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Feb 2013 16:19:07 +0000 (16:19 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Feb 2013 16:19:07 +0000 (16:19 +0000)
527 files changed:
PYTHIA8/CMakelibAliPythia8.pkg
PYTHIA8/CMakelibpythia8.pkg
PYTHIA8/pythia8170/AUTHORS [new file with mode: 0644]
PYTHIA8/pythia8170/CODINGSTYLE [new file with mode: 0644]
PYTHIA8/pythia8170/COPYING [new file with mode: 0644]
PYTHIA8/pythia8170/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8170/Makefile [new file with mode: 0644]
PYTHIA8/pythia8170/Makefile.msc [new file with mode: 0644]
PYTHIA8/pythia8170/README [new file with mode: 0644]
PYTHIA8/pythia8170/README.HepMC [new file with mode: 0644]
PYTHIA8/pythia8170/README.Win32 [new file with mode: 0644]
PYTHIA8/pythia8170/configure [new file with mode: 0755]
PYTHIA8/pythia8170/examples/LHAupAlpgen.h [new file with mode: 0644]
PYTHIA8/pythia8170/examples/MLMhooks.h [new file with mode: 0644]
PYTHIA8/pythia8170/examples/Makefile [new file with mode: 0644]
PYTHIA8/pythia8170/examples/README [new file with mode: 0644]
PYTHIA8/pythia8170/examples/cmssm.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/configure [new file with mode: 0755]
PYTHIA8/pythia8170/examples/main01.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main02.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main03.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main03.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main04.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main04.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main05.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main06.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main07.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main07.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main08.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main08.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main09.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main10.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main11.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main12.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main13.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main13.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main14.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main15.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main16.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main16.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main17.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main18.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main19.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main20.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main21.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main22.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main23.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main24.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main24.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main25.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main25.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main26.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main27.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main28.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main31.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main31.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main32.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main32.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main32.unw [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main32_unw.par [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main41.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main42.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main42.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main51.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main52.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main53.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main53.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main61.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main61.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main62.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main62.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main71.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main72.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main81.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main81.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main82.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main82.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main83.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main84.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main84.cmnd [new file with mode: 0644]
PYTHIA8/pythia8170/examples/main91.cc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out01 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out02 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out03 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out04 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out05 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out06 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out07 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out08 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out09 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out10 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out11 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out12 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out13 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out14 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out15 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out16 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out17 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out18 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out19 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out20 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out21 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out22 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out23 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out24 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out25 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out26 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out27 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/outref/out28 [new file with mode: 0644]
PYTHIA8/pythia8170/examples/photoninproton.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/powheg-dijets.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/powheg-hvq.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/runmains [new file with mode: 0755]
PYTHIA8/pythia8170/examples/snowmass2.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/softsusy.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/sps1aNarrowStopGluino.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/sps1aNarrowStopGluinoRPV.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/sps1aWithDecays.spc [new file with mode: 0644]
PYTHIA8/pythia8170/examples/ttbar.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/ttbar2.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/w+_production_lhc_0.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/w+_production_lhc_1.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/examples/w+_production_lhc_2.lhe [new file with mode: 0644]
PYTHIA8/pythia8170/hepmcinterface/HepMCInterface.cc [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ASecondHardProcess.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/AdvancedUsage.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/AlpgenAndMLM.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/BeamParameters.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/BeamRemnants.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/BeamShape.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Bibliography.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/BoseEinsteinEffects.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/COPYING [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/CompositenessProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/CouplingsAndScales.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Diffraction.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ElectroweakProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ErrorChecks.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/EventAnalysis.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/EventInformation.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/EventRecord.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/EventStatistics.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ExternalDecays.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ExtraDimensionalProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/FlavourSelection.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/FourVectors.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/FourthGenerationProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Fragmentation.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Frontpage.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Glossary.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/HadronLevelStandalone.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/HadronScattering.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/HepMCInterface.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/HiddenValleyProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/HiggsProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Histograms.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ImplementNewShowers.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Index.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/JetFinders.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/LeftRightSymmetryProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/LeptoquarkProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/LesHouchesAccord.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/MadGraph5Processes.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/MainProgramSettings.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/MasterSwitches.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/MatrixElementMerging.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/MultipartonInteractions.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/NewGaugeBosonProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/OniaProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/PDFSelection.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ParticleData.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ParticleDataScheme.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ParticleDecays.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ParticleProperties.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/PartonDistributions.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/PhaseSpaceCuts.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ProcessSelection.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ProgramClasses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ProgramFiles.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ProgramFlow.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ProgramMethods.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/QCDProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/RHadrons.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/RIVETusage.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ROOTusage.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/RandomNumberSeed.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/RandomNumbers.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/ResonanceDecays.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SUSYLesHouchesAccord.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SUSYProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SampleMainPrograms.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SaveSettings.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SemiInternalProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SemiInternalResonances.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SettingsScheme.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/SpacelikeShowers.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/StandardModelParameters.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/TimelikeShowers.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/TopProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/TotalCrossSections.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Tunes.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/UpdateHistory.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/UserHooks.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Version.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/Welcome.html [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/pythia.css [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/pythia32.gif [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/pythia8100.pdf [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/pythia99.gif [new file with mode: 0644]
PYTHIA8/pythia8170/htmldoc/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8170/include/Analysis.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/Basics.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/BeamParticle.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/BeamRemnants.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/BeamShape.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/BoseEinstein.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/Event.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/FastJet3.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/FragmentationFlavZpT.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/FragmentationSystems.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HadronLevel.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HadronScatter.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HelicityBasics.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HelicityMatrixElements.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HepMCInterface.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/HiddenValleyFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/History.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/Info.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/LHAFortran.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/LHAPDFInterface.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/LesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/MergingHooks.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/MiniStringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/MultipartonInteractions.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ParticleData.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ParticleDecays.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PartonDistributions.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PartonLevel.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PartonSystems.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PhaseSpace.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ProcessContainer.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ProcessLevel.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/Pythia.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PythiaComplex.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/PythiaStdlib.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/RHadrons.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ResonanceDecays.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/ResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/Settings.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaCompositeness.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaEW.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaExtraDim.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaGeneric.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaHiggs.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaLeftRightSym.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaLeptoquark.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaNewGaugeBosons.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaOnia.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaProcess.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaQCD.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaSUSY.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SigmaTotal.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SpaceShower.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/StandardModel.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/StringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SusyCouplings.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SusyLesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/SusyResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/TauDecays.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/TimeShower.h [new file with mode: 0644]
PYTHIA8/pythia8170/include/UserHooks.h [new file with mode: 0644]
PYTHIA8/pythia8170/lhapdfdummy/LHAPDFDummy.cc [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ASecondHardProcess.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/AdvancedUsage.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/AlpgenAndMLM.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/BeamParameters.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/BeamRemnants.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/BeamShape.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Bibliography.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/BoseEinsteinEffects.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/COPYING [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/CompositenessProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/CouplingsAndScales.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Diffraction.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ElectroweakProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ErrorChecks.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/EventAnalysis.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/EventInformation.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/EventRecord.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/EventStatistics.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ExternalDecays.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ExtraDimensionalProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/FlavourSelection.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/FourVectors.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/FourthGenerationProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Fragmentation.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Frontpage.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Glossary.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/HadronLevelStandalone.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/HadronScattering.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/HepMCInterface.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/HiddenValleyProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/HiggsProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Histograms.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ImplementNewShowers.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Index.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/JetFinders.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/LeftRightSymmetryProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/LeptoquarkProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/LesHouchesAccord.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/MadGraph5Processes.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/MainProgramSettings.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/MasterSwitches.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/MatrixElementMerging.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/MultipartonInteractions.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/NewGaugeBosonProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/OniaProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/PDFSelection.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ParticleData.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ParticleDataScheme.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ParticleDecays.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ParticleProperties.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/PartonDistributions.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/PhaseSpaceCuts.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ProcessSelection.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ProgramClasses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ProgramFiles.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ProgramFlow.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ProgramMethods.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/QCDProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/RHadrons.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/RIVETusage.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ROOTusage.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/RandomNumberSeed.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/RandomNumbers.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/ResonanceDecays.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SUSYLesHouchesAccord.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SUSYProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SampleMainPrograms.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SaveSettings.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SemiInternalProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SemiInternalResonances.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SettingsScheme.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/SpacelikeShowers.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/StandardModelParameters.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/TimelikeShowers.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/TopProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/TotalCrossSections.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Tunes.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/UpdateHistory.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/UserHooks.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Version.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/Welcome.php [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/php.txt [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/pythia.css [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/pythia32.gif [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/pythia8100.pdf [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/pythia99.gif [new file with mode: 0644]
PYTHIA8/pythia8170/phpdoc/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/Makefile [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/README [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/hist.cc [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/pythiaLinkdef.h [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/pythiaROOT.h [new file with mode: 0644]
PYTHIA8/pythia8170/rootexamples/tree.cc [new file with mode: 0644]
PYTHIA8/pythia8170/src/Analysis.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/Basics.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/BeamParticle.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/BeamRemnants.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/BeamShape.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/BoseEinstein.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/Event.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/FragmentationFlavZpT.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/FragmentationSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/HadronLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/HadronScatter.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/HelicityBasics.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/HelicityMatrixElements.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/HiddenValleyFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/History.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/Info.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/LesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/MergingHooks.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/MiniStringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/MultipartonInteractions.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ParticleData.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ParticleDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/PartonDistributions.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/PartonLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/PartonSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/PhaseSpace.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ProcessContainer.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ProcessLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/Pythia.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/PythiaStdlib.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/RHadrons.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ResonanceDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/ResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/Settings.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaCompositeness.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaEW.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaExtraDim.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaGeneric.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaHiggs.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaLeftRightSym.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaLeptoquark.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaNewGaugeBosons.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaOnia.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaProcess.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaQCD.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaSUSY.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SigmaTotal.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SpaceShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/StandardModel.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/StringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SusyCouplings.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SusyLesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/SusyResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/TauDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/TimeShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/src/UserHooks.cxx [new file with mode: 0644]
PYTHIA8/pythia8170/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ASecondHardProcess.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/AdvancedUsage.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/AlpgenAndMLM.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/BeamParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/BeamRemnants.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/BeamShape.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Bibliography.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/BoseEinsteinEffects.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/CompositenessProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/CouplingsAndScales.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Diffraction.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ElectroweakProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ErrorChecks.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/EventAnalysis.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/EventInformation.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/EventRecord.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/EventStatistics.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ExternalDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ExtraDimensionalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/FlavourSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/FourVectors.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/FourthGenerationProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Fragmentation.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Frontpage.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Glossary.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/HadronLevelStandalone.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/HadronScattering.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/HepMCInterface.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/HiddenValleyProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/HiggsProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Histograms.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ImplementNewShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Index.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/JetFinders.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/LeftRightSymmetryProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/LeptoquarkProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/LesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/MadGraph5Processes.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/MainProgramSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/MasterSwitches.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/MatrixElementMerging.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/MultipartonInteractions.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/NewGaugeBosonProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/OniaProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/PDFSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ParticleData.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ParticleDataScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ParticleDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ParticleProperties.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/PartonDistributions.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/PhaseSpaceCuts.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ProcessSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ProgramClasses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ProgramFiles.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ProgramFlow.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ProgramMethods.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/QCDProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/RHadrons.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/RIVETusage.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ROOTusage.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/RandomNumberSeed.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/RandomNumbers.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ResonanceDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SUSYLesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SUSYProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SampleMainPrograms.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SaveSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SemiInternalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SemiInternalResonances.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SettingsScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/SpacelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/StandardModelParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/TimelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/TopProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/TotalCrossSections.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Tunes.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/UpdateHistory.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/UserHooks.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Version.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/Welcome.xml [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ct09mc1.pds [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ct09mc2.pds [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ct09mcs.pds [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/cteq6l.tbl [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/cteq6l1.tbl [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/ctq66.00.pds [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/lejon2.eps [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/mrstlostar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/mrstlostarstar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/mstw2008lo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/mstw2008nlo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/piK-Estabrooks.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/piN-SAID-WI08.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pipi-Froggatt.dat [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1FitA.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1FitB.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1FitBlo.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1JetsCharm.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1JetsGluon.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pomH1JetsSinglet.data [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pythia8100.tex [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/pythiapicture.eps [new file with mode: 0644]
PYTHIA8/pythia8170/xmldoc/worksheet.tex [new file with mode: 0644]

index 4d13928..9ea16f0 100644 (file)
@@ -36,4 +36,4 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 set ( DHDR  AliPythia8LinkDef.h)
 
-set ( EINCLUDE PYTHIA8/pythia8145/include PYTHIA6 STEER/STEER STEER/STEERBase)
+set ( EINCLUDE PYTHIA8/pythia8170/include PYTHIA6 STEER/STEER STEER/STEERBase)
index 25c013c..82c129e 100644 (file)
 #--------------------------------------------------------------------------------#
 
 set ( SRCS  
-    pythia8145/src/Analysis.cxx 
-    pythia8145/src/Basics.cxx 
-    pythia8145/src/BeamParticle.cxx 
-    pythia8145/src/BeamRemnants.cxx 
-    pythia8145/src/BeamShape.cxx 
-    pythia8145/src/BoseEinstein.cxx 
-    pythia8145/src/Event.cxx 
-    pythia8145/src/FragmentationFlavZpT.cxx 
-    pythia8145/src/FragmentationSystems.cxx 
-    pythia8145/src/HadronLevel.cxx 
-    pythia8145/src/Info.cxx 
-    pythia8145/src/LesHouches.cxx 
-    pythia8145/src/MiniStringFragmentation.cxx 
-    pythia8145/src/MultipleInteractions.cxx 
-    pythia8145/src/ParticleData.cxx 
-    pythia8145/src/ParticleDecays.cxx 
-    pythia8145/src/PartonDistributions.cxx 
-    pythia8145/src/PartonLevel.cxx 
-    pythia8145/src/PartonSystems.cxx 
-    pythia8145/src/PhaseSpace.cxx 
-    pythia8145/src/ProcessContainer.cxx 
-    pythia8145/src/ProcessLevel.cxx 
-    pythia8145/src/Pythia.cxx 
-    pythia8145/src/PythiaStdlib.cxx 
-    pythia8145/src/ResonanceDecays.cxx 
-    pythia8145/src/ResonanceWidths.cxx 
-    pythia8145/src/Settings.cxx 
-    pythia8145/src/SigmaCompositeness.cxx 
-    pythia8145/src/SigmaEW.cxx 
-    pythia8145/src/SigmaExtraDim.cxx 
-    pythia8145/src/SigmaGeneric.cxx 
-    pythia8145/src/SigmaHiggs.cxx 
-    pythia8145/src/SigmaLeftRightSym.cxx 
-    pythia8145/src/SigmaLeptoquark.cxx 
-    pythia8145/src/SigmaNewGaugeBosons.cxx 
-    pythia8145/src/SigmaOnia.cxx 
-    pythia8145/src/SigmaProcess.cxx 
-    pythia8145/src/SigmaQCD.cxx 
-    pythia8145/src/SigmaSUSY.cxx 
-    pythia8145/src/SigmaTotal.cxx 
-    pythia8145/src/SpaceShower.cxx 
-    pythia8145/src/StandardModel.cxx 
-    pythia8145/src/StringFragmentation.cxx 
-    pythia8145/src/SusyCouplings.cxx 
-    pythia8145/src/SusyLesHouches.cxx 
-    pythia8145/src/TimeShower.cxx 
-    pythia8145/src/UserHooks.cxx 
-    pythia8145/src/SusyResonanceWidths.cxx 
+    pythia8170/src/Analysis.cxx 
+    pythia8170/src/Basics.cxx 
+    pythia8170/src/BeamParticle.cxx 
+    pythia8170/src/BeamRemnants.cxx 
+    pythia8170/src/BeamShape.cxx 
+    pythia8170/src/BoseEinstein.cxx 
+    pythia8170/src/Event.cxx 
+    pythia8170/src/FragmentationFlavZpT.cxx 
+    pythia8170/src/FragmentationSystems.cxx 
+    pythia8170/src/HadronLevel.cxx 
+    pythia8170/src/HadronScatter.cxx
+    pythia8170/src/HelicityBasics.cxx
+    pythia8170/src/HelicityMatrixElements.cxx
+    pythia8170/src/HiddenValleyFragmentation.cxx
+    pythia8170/src/History.cxx
+    pythia8170/src/Info.cxx 
+    pythia8170/src/LesHouches.cxx 
+    pythia8170/src/MergingHooks.cxx 
+    pythia8170/src/MiniStringFragmentation.cxx 
+    pythia8170/src/MultipartonInteractions.cxx 
+    pythia8170/src/ParticleData.cxx 
+    pythia8170/src/ParticleDecays.cxx 
+    pythia8170/src/PartonDistributions.cxx 
+    pythia8170/src/PartonLevel.cxx 
+    pythia8170/src/PartonSystems.cxx 
+    pythia8170/src/PhaseSpace.cxx 
+    pythia8170/src/ProcessContainer.cxx 
+    pythia8170/src/ProcessLevel.cxx 
+    pythia8170/src/Pythia.cxx 
+    pythia8170/src/PythiaStdlib.cxx
+    pythia8170/src/RHadrons.cxx 
+    pythia8170/src/ResonanceDecays.cxx 
+    pythia8170/src/ResonanceWidths.cxx 
+    pythia8170/src/Settings.cxx 
+    pythia8170/src/SigmaCompositeness.cxx 
+    pythia8170/src/SigmaEW.cxx 
+    pythia8170/src/SigmaExtraDim.cxx 
+    pythia8170/src/SigmaGeneric.cxx 
+    pythia8170/src/SigmaHiggs.cxx 
+    pythia8170/src/SigmaLeftRightSym.cxx 
+    pythia8170/src/SigmaLeptoquark.cxx 
+    pythia8170/src/SigmaNewGaugeBosons.cxx 
+    pythia8170/src/SigmaOnia.cxx 
+    pythia8170/src/SigmaProcess.cxx 
+    pythia8170/src/SigmaQCD.cxx 
+    pythia8170/src/SigmaSUSY.cxx 
+    pythia8170/src/SigmaTotal.cxx 
+    pythia8170/src/SpaceShower.cxx 
+    pythia8170/src/StandardModel.cxx 
+    pythia8170/src/StringFragmentation.cxx 
+    pythia8170/src/SusyCouplings.cxx 
+    pythia8170/src/SusyLesHouches.cxx 
+    pythia8170/src/TimeShower.cxx 
+    pythia8170/src/TauDecays.cxx                 
+    pythia8170/src/UserHooks.cxx 
+    pythia8170/src/SusyResonanceWidths.cxx 
     )
 
-set (EINCLUDE PYTHIA8/pythia8145/include)
+set (EINCLUDE PYTHIA8/pythia8170/include)
 
 if( ALICE_TARGET STREQUAL "macosxicc")
        
diff --git a/PYTHIA8/pythia8170/AUTHORS b/PYTHIA8/pythia8170/AUTHORS
new file mode 100644 (file)
index 0000000..4dbb846
--- /dev/null
@@ -0,0 +1,6 @@
+Torbjorn Sjostrand <torbjorn@thep.lu.se>
+Stefan Ask <Stefan.Ask@cern.ch>
+Richard Corke <richard.corke@thep.lu.se>
+Stephen Mrenna <mrenna@fnal.gov>
+Stefan Prestel <stefan.prestel@thep.lu.se> 
+Peter Skands <peter.skands@cern.ch>
diff --git a/PYTHIA8/pythia8170/CODINGSTYLE b/PYTHIA8/pythia8170/CODINGSTYLE
new file mode 100644 (file)
index 0000000..b931b49
--- /dev/null
@@ -0,0 +1,345 @@
+Coding Style
+
+This file is only intended for contributors of code to Pythia 8. 
+As a normal user you need not read it.
+
+A reasonably consistent coding style enhances readability and 
+understanding of code, so do take the time to make new code 
+blend smoothly with the existing structure. That said, complete
+consistency is impossible, and style must always come second to
+content. So any rules should be applied with common sense. 
+
+Remember to update the xmldoc documentation in parallel with the 
+code updates. The xml rules are provided after the coding rules.
+
+-----------------------------------------------------------------------
+
+For the Pythia8 code some principles have been used, some by
+deliberate decision, while others evolved organically. 
+An incomplete list is as follows.
+
+ 1. Use existing files to get a feel for the general outlay. 
+    (Especially the "core" files that have set the standard for
+    later writing, e.g. Pythia, Event, or Basics.)  
+
+ 2. Use standard C++, in a clear and consistent manner. Do not 
+    show off by using special tricks that only experts will 
+    appreciate. Do not use any experimental language features. 
+
+ 3. English is the only allowed language (for comments, variable
+    names, etc.).
+
+ 4. Lines should be at most 79 characters long, so that they do 
+    not overflow when opened in an 80 characters wide text editor
+    window. This number includes any trailing blanks, another
+    "feature" that should be avoided. 
+ 5. Never make code dependent on the presence of external libraries.
+    Some libraries, like LHAPDF and HepMC are already interfaced,
+    but only in well-defined non-critical manners. If you want to
+    include interfaces to new libraries, or modify the existing ones,
+    you should bring it up for open discussion beforehand.
+
+ 6. The underscore "character" should be avoided as far as possible;
+    it makes code difficult to read. See also point 24. Currently it 
+    is only used in headers, for #ifndef Pythia8_filename_H. 
+
+ 7. Extra code used for debugging purposes, or left behind from
+    the development process, even if commented out, should be
+    removed from the public version. Feel free to save your own 
+    private versions where such code is available.
+
+ 8. Begin each code file with 
+// (filename) is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+    to establish the legal structure. Follow that with specific
+    information on authorship of the particular file, where relevant,
+    and a very brief summary of the contents. After that follow with
+    #include and other preprocessor commands and namespace Pythia8 {, 
+    before the actual code. 
+
+ 9. Use lines  
+//==========================================================================
+    to separate classes from each other, and from top and bottom 
+    material of a file, that does not belong to a class.
+
+10. Use lines
+//--------------------------------------------------------------------------
+    for smaller subdivisions than above. Specifically, in .cc files,
+    insert it between the different methods that belong to the same
+    class. 
+
+11. Blank lines should be used to separate the code into suitable
+    chunks of statements that belong together. Never use two or
+    more blank lines consecutively, however.
+
+12. Begin each code chunk with one or more comment lines that 
+    explains the purpose of this chunk. Do not overdo documentation,
+    however: the purpose is to provide overview, not clutter.
+13. Comment lines may also precede a particularly crucial statement
+    inside a code chunk, without the need for a blank line before.
+
+14. Do not add comments on the same line as a statement:
+       a = b + c;   // No comment here!  
+
+15. Write comments in terms of (cryptic but) correct English, with
+    relevant punctuation.
+
+16. Do not use /* .... */ : not for code because all such code 
+    should have been removed in the first place (point 7), and not 
+    for comments since intent is more obvious if all comment lines
+    begin with //.
+  
+17. Indent two further steps for each new logical substructure
+    (loops, conditional statements, etc.). The namespace {, public:
+    and private: are exceptions to this rule, requiring no extra
+    indentation. 
+
+18. Do not use tabs for formatting; it may give a mess when read by 
+    another user. 
+
+19. Use exactly one space to separate logical structures and operators:
+    if (a == b) then {
+    If readibility can be improved by lining up nearby statements then
+    this is allowed to take precedence, however:
+    int    iNew = 0;
+    double pm   = 0.;
+20. One area of inconsistency is whether a blank is used after ( or not:
+    void status(int statusIn) {statusSave = statusIn;}
+    virtual void set1Kin( double x1in, double x2in, double sHin);
+    If there is a thought, it is that for short constructions a blank
+    tends to unnecessarily break up the structure, while for longer ones
+    such breaks are necessary to gain overview. Similarly ( ( may often
+    be used to give better structure than ((.
+
+21. Allow several statements on the same line in header files, since
+    operations here should be simple and short. Avoid it in .cc files,
+    where one may want to more carefully study the logical structure,
+    and could more easily miss statements that way.
+
+22. Do not use pointers more than you absolutely need to. For most usage
+    a reference is much nicer, but unfortunetely it cannot be saved.
+    If you need a pointer, have its name end with Ptr, so it is easily
+    recognized. In declarations the * goes with the pointer type:
+    Info* infoPtr;  
+    rather than e.g. Info *infoPtr. 
+
+23. Class names should begin with a capital letter, whereas instances of
+    this class begin lowercase. Also methods and local variable names 
+    should begin lowercase. Only static const VARIABLENAME are given in 
+    uppercase throughout. 
+
+24. Use capitalization inside a word to help reading, e.g.
+    pAbs, toCMframe, useNewBeamShape, skipInit.
+    Descriptive names are helpful, but don't make them longer than 
+    they have to (thisVariableSumsAllDiagonalMatrixElements is better
+    replaced by sumDiag).
+
+25. It is useful if index names begin with an i (or j, k if several 
+    are needed) and sizes with an n.
+26. Pick ++i instead of i++, unless the latter is intentional.
+    Recall that ++i is updated at the point it is encountered, 
+    while i++ implies it need only be updated after other operations
+    have taken place, which can be confusing.
+
+27. Use int for all integers, except where potential overflow warrants
+    long, and avoid unsigned integers. 
+
+28. Use double for all real variables.
+
+29. Use the Pythia complex type for all complex variables, defined by
+    typedef std::complex<double> complex;
+    in PythiaComplex.h
+
+30. Use the Pythia Vec4 class for four-vectors.
+
+31. Use string for all text, except when C++ leaves you no option but
+    to use char or char*, e.g. for the name of a file to be opened.
+
+32. Use the Boolean operators &&, || and !, not the alternative old
+    cleartext "and", "or" and "not".
+
+33. Do not use cast notation where function style is possible,
+    i.e. int i = int(r); rather than int i = (int)r;.
+
+34. Do not use typedef (except in point 29 above). 
+
+35. Units of GeV for energies and mm for distances are implicit,
+    with c = 1 so the same units can be used for momentum, mass 
+    and time.
+
+36. If an expression needs to be split over lines, let the new line
+    begin with an operator, so that the reason for several lines is 
+    apparent:
+    double sum = a + b + c + d
+               + e + f + g;
+    alternatively
+    double sum = a + b + c + d
+      + e + f + g;
+    (i.e. lined-up or indented-two-steps, whatever is most convenient). 
+
+37. Be very restrictive with output from your methods. Some limited
+    initialization info may be relevant, but desist if you can.
+    During running printing should either be located in special methods 
+    that the user has to call explicitly (with ostream& os = cout as 
+    last argument) or, for error messages, make use of the 
+    Info::errorMsg(..) method.
+
+38. No global variables. It should be possible to have several 
+    instances of Pythia running without any risk of interference
+    between them. 
+
+39. Do not have a { on a line of its own, but allow a lone } at
+    the very end of the conditions/loops (or, for longer pieces of 
+    code, at the end of each conditions case):
+    if (isCharged) {
+      statements;
+    } else {
+      more statements; 
+    } 
+
+40. Use the standard constant M_PI for the value of pi = 3.141592...
+
+41. Use pow2(double), pow3(double), pow4(double), pow5(double) and 
+    pow6(double) for small positive integer powers, since the standard
+    pow(double, double) can be very slow for such operations.
+
+42. The event record, both the process and event ones, are always 
+    passed as references rather than pointers. This allows notation 
+    like event[i].p() rather than (*eventPtr)[i].p(); note that 
+    eventPtr[i]->p() is not allowed C++ notation. 
+
+43. Use standard names for some of the other class instances, like
+    infoPtr, particleDataPtr, rndmPtr, beamAPtr, beamBPtr, couplingsPtr,
+    partonSystemsPtr, userHooksPtr, etc..The Settings database is normally
+    only interrogated during initializations, so is usually passad as
+    reference settings rather than pointer settingsPtr.
+
+44. Only use == and != for comparisons between two pointers,  
+    or a pointer and 0. Thus comparisons like (Xptr > 0) are forbidden.
+
+-----------------------------------------------------------------------
+
+Remember to update the xmldoc documentation in parallel with the 
+code updates. All the details should make it directly into the 
+respective webpage, with UpdateHistory.xml only giving a very 
+brief summary. (This is different from Pythia 6, where the update
+notes had to be complete.)
+
+The xml notes are not intended to be read by users, who instead will
+access the html and php equivalents. The translation from xml to 
+html and php is done with a specially written conversion program.
+This program is not distributed with the code, to avoid abuse by 
+users, but will be run from time to time. The program handles a set
+of new tags, and additionally you can use many standard html ones,
+which are passed on without any action. 
+
+Outlined below is the set of xml tags in current use, that are 
+covered by a translation program. Also a few other open issues.
+
+We try to stick with xml rules, e.g. <tag>...</tag> for pair
+and <tag/> for single (=combined begin+end). Note that the parsing 
+of the conversion program assumes a "sensible" layout of the text. 
+
+A) Standard html concepts:
+<h1></h1> a top-level header;
+<h2></h2> a subheader;
+<h3></h3> a subsubheader;
+<h4></h4> a subsubsubheader;
+<br/> a new line;
+<p/> a new paragraph;
+<ol></ol> an ordered list, with <li> items;
+<ul></ul> a bulleted list, with <li> items;
+<li></li> an item in an ordered or bulleted list;
+<dl></dl> a definition list (used for references);
+<dt></dt> a definition term in a definition list;
+<dd></dd> a definition text in a definition list;
+<b></b> boldface;
+<i></i> italics - will be used for typesetting formulae so avoid for text;
+<code></code> inline computer code (teletype font);
+<pre></pre> a piece of code, with linebreaks as formatted (teletype font); 
+<a href="..." target="..."></a> anchor;
+<frameset ....></frameset> : only used in Welcome.xml;
+<frame ....></frame> : only used in Welcome.xml;
+<img src="..." alt="..." hspace=... /> only used in Index.xml;
+<table</table> and <td></td> around SaveSettings dialog box.
+
+B) New concepts for simple markup (no interactivity):
+<chapter name="..."></chapter> a large chunk of text, 
+    stored as one single xml file;
+<eq></eq> text to be displayed on a separate line, centered if possible 
+    (a poor man's equation), maybe typeset in italics (<i>);
+<ei></ei> inline variant of above;
+<note></note> text begun on new line, in boldface;
+<notenl></notenl> text begun, no linebreak, in boldface;
+<file name="..."></file> name of a program file (new paragraph, boldface);
+<class name="..."></class> information on a specific class,
+    specifically the class creation command form;
+<method name="..."></method> explanation of a class method;
+<methodmore name="..."></methodmore> a class method to be listed closely
+    together with the previous one, since they belong together;
+<argument name="..." default="..."></argument> an argument of 
+    the class creation or another method in the class, optionally 
+    with a default value:
+<argoption value="..."></argoption> further explanation of an 
+    allowed option of an argument.   
+
+C) New concepts for user interaction in php files (but no interactivity 
+in html):
+<ref></ref> 
+    reference to an article; replaced by [...] and anchor;
+<aloc href="..."></aloc> 
+    anchor among local pages; automatically fills with file type and
+    target="page";
+<aidx href="..."></aidx> 
+    anchor from Index.xml to other files; automatically fills with 
+    file type and target="page";
+<flag name="..." default="..."></flag> 
+    a switch to be used in the event generation; in php shown with 
+    radio buttons to pick on (= yes, true) or off (= no, false), 
+    written to file as a line with name = value; 
+<flagfix name="..." default="..."></flagfix>
+    ditto but no interactivity;
+<modeopen name="..." default="..." min="..." max="..."></modeopen>
+    an integer value to be used in the event generation; in php
+    shown as a dialogue box where an integer can be typed in, and
+    written to file as a line with name = value; the min and max values 
+    are optional; 
+<modepick name="..." default="..." min="..." max="..."></modepick>
+    an integer value to be used in the event generation; unlike modeopen 
+    above there is a fixed set of <option>'s available, in php shown 
+    with radio buttons to pick one of them, written to file as a line 
+    with name = value; the min and max values are optional; 
+<option value="..."></option>
+    a discrete set of options for a <modepick>, see above;
+<modefix name="..." default="..." min="..." max="..."></modeopen>
+    ditto but no interactivity;
+<parm name="..." default="..." min="..." max="..."></parm>
+    a double-precision value to be used in the event generation; in php
+    shown as a dialogue box where a real number can be typed in, and
+    written to file as a line with name = value; the min and max values 
+    are optional; 
+<parmfix name="..." default="..." min="..." max="..."></parm>
+    ditto but no interactivity;
+<word name="..." default="..."></word>
+    a character string, without blanks, to be used in the event generation
+    mainly for file names; in php shown as a dialogue box where text can be 
+    typed in, and written to file as a line with name = value;
+<wordfix name="..." default="..."></wordfix>
+    ditto but no interactivity;
+
+D) New concepts that could one day be made interactive, but currently 
+are not:
+<particle id="..." name="..." antiName="..." spinType="..." 
+    chargeType="..." colType="..." m0="..." mWidth="..." mMin="..." 
+    mMax="..." tau0="..."></particle>
+    the properties of a particle, most of which are optional;
+<channel onMode="..." bRatio="..." meMode="..." products="..."/></channel>
+    the properties of a decay channel; this tag can only appear inside a
+    <particle>...</particle> block; the meMode field is optional; the
+    products appear as a blank-separated list.
diff --git a/PYTHIA8/pythia8170/COPYING b/PYTHIA8/pythia8170/COPYING
new file mode 100644 (file)
index 0000000..d511905
--- /dev/null
@@ -0,0 +1,339 @@
+                   GNU GENERAL PUBLIC LICENSE
+                      Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                   GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                           NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/PYTHIA8/pythia8170/GUIDELINES b/PYTHIA8/pythia8170/GUIDELINES
new file mode 100644 (file)
index 0000000..db9f8d2
--- /dev/null
@@ -0,0 +1,108 @@
+
+               MCNET GUIDELINES
+
+      for Event Generator Authors and Users
+
+
+    PREAMBLE
+
+This generator has been developed as part of an academic research
+project and is the result of many years of work by the authors.
+Proper academic recognition is a requirement for its continued
+development.
+
+The components of the program have been developed to work together
+as a coherent physics framework. We believe that the creation of
+separately maintained forks or piecewise distribution of individual
+parts would diminish their scientific value.
+
+The authors are convinced that software development in a scientific
+context requires full availability of all source code, to further
+progress and to allow local modifications to meet the specific
+requirements of the individual user.
+
+Therefore we have decided to release this program under the
+GNU General Public License (GPL) version 2. This ensures
+that the source code will be available to you and grants you the
+freedom to use and modify the program. You can redistribute your
+modified versions as long as you retain the GPL and respect existing
+copyright notices (see the file 'COPYING' for details).
+
+By using the GPL, we entrust you with considerable freedom and expect
+you to use it wisely, since the GPL does not address the issues in
+the first two paragraphs. To remedy this shortcoming, we have
+formulated the following guidelines relevant for the distribution
+and usage of event generator software in an academic setting.
+
+
+    GUIDELINES
+
+1) The integrity of the program should be respected.
+    -------------------------------------------------
+
+1.1) Suspected bugs and proposed fixes should be reported back to the
+    original authors to be considered for inclusion in the standard
+    distribution.  No independently developed and maintained forks
+    should be created as long as the original authors actively work on
+    the program.
+
+1.2) The program should normally be redistributed in its entirety.
+    When there are special reasons, an agreement should be sought with
+    the original authors to redistribute only specific parts. This
+    should be arranged such that the redistributed parts remain
+    updated in step with the standard distribution.
+
+1.3) Any changes in the code must be clearly marked in the source
+   (reason, author, date) and documented. If any modified version is
+   redistributed it should be stated at the point of distribution
+   (download link) that it has been modified and why.
+
+1.4) If a significant part of the code is used by another program,
+    this should be clearly specified in that program's documentation and
+    stated at its point of distribution.
+
+1.5) Copyright information and references may not be removed.
+    Copyright-related program messages may not be altered and must be
+    printed even if only a part of the program is used. Adding further
+    messages specifying any modifications is encouraged.
+
+
+2) The program and its physics should be properly cited when used for
+    academic publications
+    ------------------------------------------------------------------
+
+2.1) The main software reference as designated by the program authors
+    should always be cited.
+
+2.2) In addition, the original literature on which the program is based
+    should be cited to the extent that it is of relevance for a study,
+    applying the same threshold criteria as for other literature.
+
+2.3) When several programs are combined, they should all be mentioned,
+    commensurate with their importance for the physics study at hand.
+
+2.4) To make published results reproducible, the exact versions of the
+    codes that were used and any relevant program and parameter
+    modifications should be spelled out.
+
+
+    POSTSCRIPT
+
+The copyright license of the software is the GPL v2 alone, therefore
+the above guidelines are not legally binding. However, we reserve the
+right to criticize offenders. The guidelines should always be combined
+with common sense, for interpretation and for issues not covered.
+Enquiries regarding the guidelines and related issues are encouraged
+and should be directed to the authors of the program.
+
+Please note that the program, including all its code and documentation,
+is intended for academic use and is delivered "as is" to be used at 
+your own risk, without any guarantees.
+
+----------------------------------------------------------------------
+
+These guidelines were edited by Nils Lavesson and David Grellscheid
+for the MCnet collaboration, which has approved and agreed to respect
+them.  MCnet is a Marie Curie Research Training Network funded under
+Framework Programme 6 contract MRTN-CT-2006-035606.
+
diff --git a/PYTHIA8/pythia8170/Makefile b/PYTHIA8/pythia8170/Makefile
new file mode 100644 (file)
index 0000000..3a253a7
--- /dev/null
@@ -0,0 +1,246 @@
+#
+# Libraries Makefile. Some ideas from Geant4 Makefiles
+#
+#                  M. Kirsanov 07.04.2006
+#                     Modified 18.11.2006
+#                     26.03.2008 CLHEP dependency removed
+#                  N. Lavesson 28.04.2009 clean/distclean separated
+#                  M. Kirsanov 21.07.2009 Mac-OSX flags added
+
+SHELL = /bin/sh
+
+-include config.mk
+
+# flags:
+#
+#FFLAGSSHARED = -fPIC
+CFLAGSSHARED = -fPIC
+CXXFLAGSSHARED = -fPIC
+
+
+HEPMCERROR=
+ifneq (x$(HEPMCLOCATION),x)
+ ifeq ($(wildcard $(HEPMCLOCATION)/include/HepMC/*.h),)
+  HEPMCERROR= HepMC interface: ERROR, no HepMC headers found in ${HEPMCLOCATION}/include/HepMC
+ endif
+endif
+
+# Location of directories.
+MYTMPDIR=tmp
+TOPDIR=$(shell \pwd)
+INCDIR=include
+SRCDIR=src
+LIBDIR=lib
+LIBDIRARCH=lib/archive
+BINDIR=bin
+
+# Location of libraries to be built.
+ifeq ($(SHAREDLIBS),yes)
+  targets=$(LIBDIRARCH)/libpythia8.a
+  targets+=$(LIBDIR)/libpythia8.$(SHAREDSUFFIX)
+  targets+=$(LIBDIRARCH)/liblhapdfdummy.a
+  targets+=$(LIBDIR)/liblhapdfdummy.$(SHAREDSUFFIX)
+else
+  targets=$(LIBDIRARCH)/libpythia8.a
+  targets+=$(LIBDIRARCH)/liblhapdfdummy.a
+endif
+
+ifneq (x$(HEPMCLOCATION),x)
+ targets+=$(LIBDIRARCH)/libhepmcinterface.a
+ ifeq ($(SHAREDLIBS),yes)
+  targets+=$(LIBDIR)/libhepmcinterface.$(SHAREDSUFFIX)
+ endif
+endif
+
+
+all: $(targets) config.mk
+
+config.mk: ./configure
+       ./configure
+
+# Main part: build Pythia8 library. 
+
+$(MYTMPDIR)/%.o : $(SRCDIR)/%.cc
+       @mkdir -p $(MYTMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) -c -I$(INCDIR) $< -o $@
+
+$(MYTMPDIR)/archive/%.o : $(SRCDIR)/%.cc
+       @mkdir -p $(MYTMPDIR)/archive
+       $(CXX) $(CXXFLAGS) -c -I$(INCDIR) $< -o $@
+
+$(MYTMPDIR)/%.o : lhapdfdummy/%.cc
+       @mkdir -p $(MYTMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) -c -I$(INCDIR) $< -o $@
+
+$(MYTMPDIR)/archive/%.o : lhapdfdummy/%.cc
+       @mkdir -p $(MYTMPDIR)/archive
+       $(CXX) $(CXXFLAGS) -c -I$(INCDIR) $< -o $@
+
+# Creating the dependency files *.d
+# The compiler with option -M is used to build the dependency strings. They
+# are further edited with sed (stream editor). The first sed command adds the
+# dependency for the *.d files themselves, the second one is needed because
+# object files are put in the directory different from src. The last line
+# removes empty *.d files produced in case of error.
+
+ifeq ($(SHAREDLIBS),yes)
+  $(MYTMPDIR)/%.d : $(SRCDIR)/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(MYTMPDIR); \
+       $(CC) -M -I$(INCDIR) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*\.o/$(MYTMPDIR)\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+endif
+
+$(MYTMPDIR)/archive/%.d : $(SRCDIR)/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(MYTMPDIR)/archive; \
+       $(CC) -M -I$(INCDIR) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*\.o/$(MYTMPDIR)\/archive\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+objects := $(patsubst $(SRCDIR)/%.cc,$(MYTMPDIR)/%.o,$(wildcard $(SRCDIR)/*.cc))
+objectsarch := $(patsubst $(SRCDIR)/%.cc,$(MYTMPDIR)/archive/%.o,$(wildcard $(SRCDIR)/*.cc))
+
+$(LIBDIR)/libpythia8.$(SHAREDSUFFIX): $(objects)
+       @mkdir -p $(LIBDIR)
+       $(CXX) $(LDFLAGSSHARED) -o $@ $(objects) $(LDFLAGLIBNAME),$(notdir $@)
+
+$(LIBDIRARCH)/libpythia8.a: $(objectsarch)
+       @mkdir -p $(LIBDIRARCH)
+       ar cru $@ $(objectsarch)
+
+objdum := $(patsubst lhapdfdummy/%.cc,$(MYTMPDIR)/%.o,$(wildcard lhapdfdummy/*.cc))
+objdumarch := $(patsubst lhapdfdummy/%.cc,$(MYTMPDIR)/archive/%.o,$(wildcard lhapdfdummy/*.cc))
+
+$(LIBDIR)/liblhapdfdummy.$(SHAREDSUFFIX): $(objdum)
+       @mkdir -p $(LIBDIR)
+       $(CXX) $(LDFLAGSSHARED) -o $@ $(objdum) $(LDFLAGLIBNAME),$(notdir $@)
+
+$(LIBDIRARCH)/liblhapdfdummy.a: $(objdumarch)
+       @mkdir -p $(LIBDIRARCH)
+       ar cru $@ $(objdumarch)
+
+deps := $(patsubst $(SRCDIR)/%.cc,$(MYTMPDIR)/%.d,$(wildcard $(SRCDIR)/*.cc))
+depsarch := $(patsubst $(SRCDIR)/%.cc,$(MYTMPDIR)/archive/%.d,$(wildcard $(SRCDIR)/*.cc))
+
+
+# The "if" below is needed in order to avoid producing the dependency files
+# when you want to just clean
+
+ifeq (,$(findstring clean, $(MAKECMDGOALS)))
+-include $(deps)
+-include $(depsarch)
+endif
+
+# Build HepMC interface part if HepMC location is set.
+
+ifneq (x$(HEPMCLOCATION),x)
+ HEPMCINCLUDE=-I$(HEPMCLOCATION)/include
+
+ ifeq (x$(HEPMCERROR),x)
+
+   $(MYTMPDIR)/%.o : hepmcinterface/%.cc config.mk
+       @mkdir -p $(MYTMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) $(HEPMCVFLAG) -c -I$(INCDIR) $(HEPMCINCLUDE) $< -o $@
+
+   $(MYTMPDIR)/archive/%.o : hepmcinterface/%.cc config.mk
+       @mkdir -p $(MYTMPDIR)/archive
+       $(CXX) $(CXXFLAGS) $(HEPMCVFLAG) -c -I$(INCDIR) $(HEPMCINCLUDE) $< -o $@
+
+   $(MYTMPDIR)/%.d : hepmcinterface/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(MYTMPDIR); \
+       $(CC) -M -I$(INCDIR) $(HEPMCINCLUDE) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*.o/$(MYTMPDIR)\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+   $(MYTMPDIR)/archive/%.d : hepmcinterface/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(MYTMPDIR)/archive; \
+       $(CC) -M -I$(INCDIR) $(HEPMCINCLUDE) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*.o/$(MYTMPDIR)\/archive\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+   objectsI := $(patsubst hepmcinterface/%.cc,$(MYTMPDIR)/%.o,$(wildcard hepmcinterface/*.cc))
+   objectsIarch := $(patsubst hepmcinterface/%.cc,$(MYTMPDIR)/archive/%.o,$(wildcard hepmcinterface/*.cc))
+
+   $(LIBDIR)/libhepmcinterface.$(SHAREDSUFFIX) : $(objectsI)
+       @mkdir -p $(LIBDIR)
+       $(CXX) $(LDFLAGSSHARED) $(objectsI) -o $@ $(LDFLAGLIBNAME),$(notdir $@)
+
+   $(LIBDIRARCH)/libhepmcinterface.a : $(objectsIarch)
+       @mkdir -p $(LIBDIRARCH)
+       ar cru $(LIBDIRARCH)/libhepmcinterface.a $(objectsIarch)
+
+   depsI := $(patsubst hepmcinterface/%.cc,$(MYTMPDIR)/%.d,$(wildcard hepmcinterface/*.cc))
+   depsIarch := $(patsubst hepmcinterface/%.cc,$(MYTMPDIR)/archive/%.d,$(wildcard hepmcinterface/*.cc))
+
+   ifeq (,$(findstring clean, $(MAKECMDGOALS)))
+   -include $(depsI)
+   -include $(depsIarch)
+   endif
+
+ else
+
+   $(LIBDIRARCH)/libhepmcinterface.a $(LIBDIR)/libhepmcinterface.$(SHAREDSUFFIX) :
+       @echo $(HEPMCERROR)
+
+
+
+ endif
+
+endif
+
+
+# Install targets:
+
+ifneq (x$(INSTALLDIR),x.)
+ install: installmain installdata
+ installmain:
+       cp -r include $(INSTALLDIR)/.
+       cp -r lib $(INSTALLDIR)/.
+       cp -p config.mk $(INSTALLDIR)/.
+
+ ifneq ($(DATADIR),$(INSTALLDIR))
+  installdata:
+       cp -r xmldoc $(DATADIR)/.
+       ln -fs $(DATADIR)/xmldoc $(INSTALLDIR)/xmldoc
+ else
+  installdata:
+       cp -r xmldoc $(INSTALLDIR)/.
+ endif
+else
+ install:
+       @echo "everything is already installed"
+endif
+
+
+# Clean up: remove (almost?) everything that cannot be recreated.
+
+.PHONY: clean distclean
+
+clean:
+       rm -rf $(MYTMPDIR)
+       rm -rf $(LIBDIR)
+       rm -rf $(BINDIR)
+       cd examples; rm -rf bin; rm -f *.exe; cd -
+       cd rootexamples; rm -f *.exe; cd -
+
+distclean: clean
+       rm -f config.mk
+       rm -f *~; rm -f \#*;
+       cd $(SRCDIR); rm -f *~; rm -f \#*; cd -
+       cd $(INCDIR); rm -f *~; rm -f \#*; cd -
+       cd xmldoc; rm -f *~; rm -f \#*; cd -
+       cd htmldoc; rm -f *~; rm -f \#*; cd -
+       cd phpdoc; rm -f *~; rm -f \#*; cd -
+       cd hepmcinterface; rm -f *~; rm -f \#*; cd -
+       cd lhapdfdummy; rm -f *~; rm -f \#*; cd -
+       cd examples; rm -f *~; rm -f \#*; rm -f core*; rm -f config.*; cd -
+       cd rootexamples; rm -f *~; rm -f \#*; rm -f core*; rm -f config.*; cd -
+
diff --git a/PYTHIA8/pythia8170/Makefile.msc b/PYTHIA8/pythia8170/Makefile.msc
new file mode 100644 (file)
index 0000000..0fbe08f
--- /dev/null
@@ -0,0 +1,171 @@
+# Makefile.msc for Pythia8 on Win32/NMAKE
+# Author: Bertrand Bellenot, 02/05/2007, 04/11/2009
+!IF "$(CFG)" == ""
+CFG = Win32 Release
+!MESSAGE No configuration specified. Defaulting to Win32 Release.
+!ENDIF 
+
+!IF "$(CFG)" != "Win32 Release" && "$(CFG)" != "Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Makefile.msc" CFG="Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+
+OutPutOpt     = -out:
+
+# Win32 system with Microsoft Visual C/C++
+!include <win32.mak>
+CC            = $(cc)
+CXX           = $(cc)
+CXXFLAGS      = -EHsc -nologo -GR -DWIN32 -W3 -FIiso646.h \
+                -DVISUAL_CPLUSPLUS -D_WINDOWS -Iinclude
+LD            = $(link)
+
+!IF  "$(CFG)" == "Win32 Release"
+CXXOPT        = -O2 -MD -DNDEBUG
+LDOPT         = 
+OUTDIR        = ./Release
+!ELSEIF  "$(CFG)" == "Win32 Debug"
+CXXOPT        = -Z7 -MDd
+LDOPT         = 
+OUTDIR        = ./Debug
+!ENDIF 
+
+# Check if nmake version is 8.xx or 9.xx
+!if ([nmake /? 2>&1 | findstr /c:"Version 8\." > nul ] == 0) || \
+    ([nmake /? 2>&1 | findstr /c:"Version 9\." > nul ] == 0)
+MT_EXE        = mt -nologo -manifest $@.manifest -outputresource:$@;1
+MT_DLL        = mt -nologo -manifest $@.manifest -outputresource:$@;2
+EXTRAFLAGS    = -D_CRT_SECURE_NO_DEPRECATE
+!else
+MT_EXE        = 
+MT_DLL        = 
+EXTRAFLAGS    = -G5
+!endif
+
+####### Files
+
+SRCDIR  = src
+DUMDIR  = lhapdfdummy
+INCDIR  = include
+LIBDIR  = lib
+LIBRARY = libPythia8
+LIBDLL  = $(LIBDIR)/$(LIBRARY).dll
+LIBLIB  = $(LIBDIR)/$(LIBRARY).lib
+
+LDFLAGS = -lib /nologo /out:$(LIBLIB)
+
+OBJS =   $(OUTDIR)/Analysis.obj \
+         $(OUTDIR)/Basics.obj \
+         $(OUTDIR)/BeamParticle.obj \
+         $(OUTDIR)/BeamRemnants.obj \
+         $(OUTDIR)/BeamShape.obj \
+         $(OUTDIR)/BoseEinstein.obj \
+         $(OUTDIR)/Event.obj \
+         $(OUTDIR)/FragmentationFlavZpT.obj \
+         $(OUTDIR)/FragmentationSystems.obj \
+         $(OUTDIR)/HadronLevel.obj \
+         $(OUTDIR)/HadronScatter.obj \
+         $(OUTDIR)/HelicityBasics.obj \
+         $(OUTDIR)/HelicityMatrixElements.obj \
+         $(OUTDIR)/HiddenValleyFragmentation.obj \
+         $(OUTDIR)/History.obj \
+         $(OUTDIR)/Info.obj \
+         $(OUTDIR)/LesHouches.obj \
+         $(OUTDIR)/MergingHooks.obj \
+         $(OUTDIR)/MiniStringFragmentation.obj \
+         $(OUTDIR)/MultipartonInteractions.obj \
+         $(OUTDIR)/ParticleData.obj \
+         $(OUTDIR)/ParticleDecays.obj \
+         $(OUTDIR)/PartonDistributions.obj \
+         $(OUTDIR)/PartonLevel.obj \
+         $(OUTDIR)/PartonSystems.obj \
+         $(OUTDIR)/PhaseSpace.obj \
+         $(OUTDIR)/ProcessContainer.obj \
+         $(OUTDIR)/ProcessLevel.obj \
+         $(OUTDIR)/Pythia.obj \
+         $(OUTDIR)/PythiaStdlib.obj \
+         $(OUTDIR)/ResonanceDecays.obj \
+         $(OUTDIR)/ResonanceWidths.obj \
+         $(OUTDIR)/RHadrons.obj \
+         $(OUTDIR)/Settings.obj \
+         $(OUTDIR)/SigmaCompositeness.obj \
+         $(OUTDIR)/SigmaEW.obj \
+         $(OUTDIR)/SigmaExtraDim.obj \
+         $(OUTDIR)/SigmaGeneric.obj \
+         $(OUTDIR)/SigmaHiggs.obj \
+         $(OUTDIR)/SigmaLeftRightSym.obj \
+         $(OUTDIR)/SigmaLeptoquark.obj \
+         $(OUTDIR)/SigmaNewGaugeBosons.obj \
+         $(OUTDIR)/SigmaOnia.obj \
+         $(OUTDIR)/SigmaProcess.obj \
+         $(OUTDIR)/SigmaQCD.obj \
+         $(OUTDIR)/SigmaSUSY.obj \
+         $(OUTDIR)/SigmaTotal.obj \
+         $(OUTDIR)/SpaceShower.obj \
+         $(OUTDIR)/StandardModel.obj \
+         $(OUTDIR)/StringFragmentation.obj \
+         $(OUTDIR)/SusyCouplings.obj \
+         $(OUTDIR)/SusyLesHouches.obj \
+         $(OUTDIR)/SusyResonanceWidths.obj \
+         $(OUTDIR)/TauDecays.obj \
+         $(OUTDIR)/TimeShower.obj \
+         $(OUTDIR)/UserHooks.obj \
+# If you link to HepMC you also need HepMCInterface
+#         $(OUTDIR)/HepMCInterface.obj \
+# If you link to LHAPDF you don't want the last line
+         $(OUTDIR)/LHAPDFDummy.obj
+
+LIBS : $(OUTDIR) $(LIBDIR) $(BINDIR) $(LIBLIB)
+
+.PHONY: $(LIBS) all
+
+all: $(LIBS)
+
+"$(OUTDIR)" :
+    @if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+"$(LIBDIR)" :
+    @if not exist "$(LIBDIR)/$(NULL)" mkdir "$(LIBDIR)"
+
+$(LIBLIB) : $(OBJS)
+    $(LD) $(LDFLAGS) $(LDOPT) @<<
+  $(OBJS)
+<<
+
+.SUFFIXES: .h .cc .obj
+
+{$(INCDIR)}.h{$(OUTDIR)}.obj:
+    $(CXX) $(CXXFLAGS) $(EXTRAFLAGS) $(CXXOPT) /Fo"$(OUTDIR)/" -c $(SRCDIR)\$(@B).cc
+
+{$(SRCDIR)}.cc{$(OUTDIR)}.obj:
+    $(CXX) $(CXXFLAGS) $(EXTRAFLAGS) $(CXXOPT) /Fo"$(OUTDIR)/" -c $<
+
+{$(DUMDIR)}.cc{$(OUTDIR)}.obj:
+    $(CXX) $(CXXFLAGS) $(EXTRAFLAGS) $(CXXOPT) /Fo"$(OUTDIR)/" -c $<
+
+clean:
+   -@erase /q /s *.obj >nul 2>&1
+   -@rmdir /q /s Debug >nul 2>&1
+   -@rmdir /q /s Release >nul 2>&1
+
+distclean:      clean
+   -@erase /q "$(LIBDIR)\*.*" >nul 2>&1
+   -@rmdir /q /s lib >nul 2>&1
+
+
diff --git a/PYTHIA8/pythia8170/README b/PYTHIA8/pythia8170/README
new file mode 100644 (file)
index 0000000..9f586bf
--- /dev/null
@@ -0,0 +1,184 @@
+
+   BASIC INSTALLATION
+
+1) Once you have unpacked your tarball into a new (sub)directory,
+   the first step is to run the "configure" script. If you accept the 
+   default compiler options, and plan to run PYTHIA 8 standalone, you 
+   only have to type "./configure". This will create the file config.mk. 
+   Actually, running this script by hand is optional since "make" will 
+   run "configure" anyway, but possible errors in the paths will be 
+   less clearly visible.
+
+2) Type "gmake" or "make". This will create an archive library. 
+   On Linux systems gmake and make are usually equivalent. For others, 
+   in case of doubt, use gmake. This applies below as well.
+
+3) The library should now be ready for use. To study some examples,
+   go to the "examples" subdirectory. The README file in that 
+   subdirectory contain further instructions how executables can 
+   be built and run.
+    
+4) At any time, typing "gmake clean" will remove all files related to
+   the library compilation, including the library itself, but it will
+   not reset the configure selections. With "gmake distclean" additionally
+   the configure selection is reset, and many other temporary files are
+   removed. Output files you may have created during your test runs are
+   not affected. (A "gmake clean" is also available in the examples 
+   subdirectory, see the README there.) 
+
+----------------------------------------------------------------------
+
+   ADVANCED INSTALLATION
+
+1) If you want to set various compilation options, or prepare the 
+   linking to the HepMC external library then the "configure" script 
+   will have to do more work. There are two different ways to 
+   accomplish this.
+
+1.1)  You can use command-line arguments to set up the desired library 
+     links. The possible options are:
+     --help : prints a brief summary of the options described here.
+     --enable-debug : turns on debugging flags and turns off optimization.
+         (This makes program execution much slower. If you later want to 
+         switch optimization back on you have to rerun configure without
+         this option, since default is to allow optimization.)
+     --enable-shared : turns on shared-library creation,
+         in addition to the archive libraries always built.
+     --enable-64bits : turns on 64 bits compilation flag
+         (is automatic on many 64-bit installations, but just in case).
+     --lcgplatform=name : allows you to specify the platform assumed for
+         compilation, which also affects the assumed location of the 
+         libraries below; default is x86_64-slc5-gcc43-opt while other 
+         supported values for name include slc4_ia32_gcc34, 
+         slc4_amd64_gcc34 and slc3_ia32_gcc323 (deprecated). 
+     --installdir=name : absolute path to a directory where the compiled
+         library and header file directories will be copied, by a 
+         "gmake install" command subsequent to the "gmake" one. 
+         Note that the files in the current working directory are kept. 
+     --prefix=name : equivalent alternative to --installdir=name.
+     --datadir=name : absolute path to a directory where the xmldoc
+         data directory will be copied, by a "gmake install" command 
+         subsequent to the "gmake" one. Defaults to the same as 
+         --installdir=name if not set separately.
+     --with-hepmc=path : the path to your local copy of the HepMC library.
+         Please note that HepMC version 1 is no more supported. If the path
+         does not contain the version number you will be warned about it.    
+     --with-hepmcversion=v : a simpler alternative to the above, valid 
+         if you are using the CERN AFS LCG external area. See the HepMC
+         web site for the information about the versions currently
+         "in production"
+     --enable-gzip     : enable support for gzipped LHE file reading
+     --with-boost=path   see GZIP SUPPORT section below for
+     --with-zlib=path    further details
+     There also are a few environment variables that you can set to 
+     force the configuration process or add flags:
+     USRCXXFLAGS : to add flags. Use this variable to add -fPIC to the 
+         compilation flags for the static libraries
+     USRLDFLAGSSHARED : to add flags to the shared library build command
+     USRSHAREDSUFFIX : to force shared libraries suffix to be like this 
+         (default on MacOSX is dylib).
+
+1.2) If you want to use the external HepMC from some different location, 
+     or it is more convenient to put the paths directly into the script,
+     then you have to edit the "configure" file by hand before you run 
+     it. Search in the "configure" file for
+       HEPMCLOCATION
+     and provide the paths where you have the respective libraries
+     installed on your local platform.
+
+   Information on the selected paths is stored in the files config.mk,
+   examples/config.sh and examples/config.csh when you run "./configure".
+
+2) If you want to change the version of HepMC, you have to
+   rerun the script "configure" with relevant options, then type "make" 
+   to recompile the library hepmcinterface. If you tried already to run 
+   examples with previous versions, pay attention to the environment 
+   variable LD_LIBRARY_PATH (see README in examples).
+
+   Hints on how to install HepMC from scratch can be found in the
+   separate README.HepMC file.
+
+3) If you have two CPUs or cores on your computer then using the -j2 
+   option on make/gmake may speed up compilation.
+
+4) Necessary data are automatically loaded when you use the default 
+   PYTHIA installation directory structure and run the main programs in 
+   the examples subdirectory. However, in the general case, you must 
+   provide the path to the .xml files, originally stored in the xmldoc 
+   directory, where default settings and particle data are found. This 
+   can be done in two ways.
+
+4.1) You can set the environment variable PYTHIA8DATA to contain the 
+     location of the xmldoc directory. In the csh and tcsh shells this 
+     could e.g. be
+       setenv PYTHIA8DATA /home/myname/pythia81xx/xmldoc
+     while in other shells it could be
+       export PYTHIA8DATA=/home/myname/pythia81xx/xmldoc
+     where xx is the subversion number.
+     Recall that environment variables set locally are only defined in 
+     the current instance of the shell. The above lines should go into 
+     your .cshrc and .bashrc files, respectively, if you want a more 
+     permanent assignment.
+
+4.2) You can provide the path as argument to the Pythia constructor in 
+     your main program, e.g.
+       Pythia pythia("/home/myname/pythia81xx/xmldoc");
+     where again xx is the subversion number.
+
+   When PYTHIA8DATA is set it takes precedence, else the path in the 
+   constructor is used, else one defaults to the ../xmldoc directory.
+
+----------------------------------------------------------------------
+
+   GZIP SUPPORT (experimental)
+
+The '--enable-gzip' options turns on support for the reading of
+gzipped LHE files. It relies upon Boost and zlib to function, and
+the locations of these must be set with the '--with-boost=boost_path'
+and '--with-zlib=zlib_path' options. Specifically, it requires (note
+that .so should be replaced with .dylib for Mac OS X):
+  boost_path/include/boost/iostreams/ (with the appropriate files
+                                       in this directory)
+  boost_path/lib/libboost_iostreams.so (or boost_path/lib64/...)
+  zlib_path/libz.so
+
+Note that when compiling a final PYTHIA executable, these libraries
+must also be included, e.g.:
+  -Lboost_path/lib -lboost_iostreams -Lzlib_path -lz
+This is done automatically for the examples in the 'examples' and
+'rootexamples' directories when gzip support is enabled.
+
+When running the executable, if the Boost and zlib libraries are
+in a non-standard directory, the LD_LIBRARY_PATH (DYLD_LIBRARY_PATH
+for Mac OS X) must be set to include these directories, e.g. in a 
+bash-type shell:
+  export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:boost_path/lib:zlib_path
+
+Gzip support currently switches off the '-Wshadow' compiler option
+to avoid the possibility of a large number of warning messages.
+
+----------------------------------------------------------------------
+
+   FOR WINDOWS USERS
+
+The Makefile.msc file is intended for use on Win32/NMAKE systems with 
+the  Microsoft Visual C/C++ compiler. This alternative installation
+is not the development platform, however, and therefore not as well 
+tested. Not all parts of the above installation procedure are the same,
+so some experimentation may be required. A few suggestions are found 
+in the the separate README.Win32 file.    
+
+----------------------------------------------------------------------
+
+   LEARN MORE
+
+To learn more about the current program:
+
+A) A brief self-contained introduction is found in the 
+   htmldoc/pythia8100.pdf file.
+
+B) Details can be found by opening a web browser on the 
+   htmldoc/Welcome.html file, and then navigating among the pages 
+   in the index there.   
+
+----------------------------------------------------------------------
diff --git a/PYTHIA8/pythia8170/README.HepMC b/PYTHIA8/pythia8170/README.HepMC
new file mode 100644 (file)
index 0000000..b8ce292
--- /dev/null
@@ -0,0 +1,101 @@
+How to install HepMC on your laptop (Linux/Mac OSX) and link to Pythia
+
+Here are two alternative recipes, one simpler with a more recent version
+and one more flexible with an older one. 
+Note: This comes with no guarantee; it is what worked for me.
+Other combinations should also work, but have not been tried.
+
+------------------------------------------------------------------------
+
+Alternative A, with HepMC 2.06.08.
+
+1) Create a directory where you want to do the installation, e.g.
+     mkdir hepmc
+and move to it
+     cd hepmc
+
+2) Open
+     http://lcgapp.cern.ch/project/simu/HepMC/download 
+in a browser, scroll down to "HepMC 2.06.08" and  pick the version relevant 
+for your platform from the list to the right. If there is no match, you 
+have to go for Alternative B below.
+
+3) In the pop-up menu pick "Save to file" and then the above hepmc directory.
+You should now have the appropriate version in that directory,
+e.g. HepMC-2.06.08-x86_64-mac106-gcc42-opt.tar.gz on a current Mac.
+
+4) Unpack with
+    tar -xzf file.tar.gz
+with "file" the name of the downloaded file. This will create a new directory, 
+e.g. x86_64-mac106-gcc42-opt/, where ready-to-use libraries can be found.
+
+5) Now move to your pythia8160 (or later) directory and configure with
+     ./configure --with-hepmc=mypath/hepmc/newdir --with-hepmcversion=2.06.08
+   where "mypath" is the absolute path to the hepmc directory (use pwd if 
+   in doubt) and "newdir" is the name of the new directory created in step 4.
+   (Re)compile with "make" (or "gmake") as usual.
+
+6) Move to the examples subdirectory and do
+     source config.sh
+     source config.csh
+Only one of them will work, depending on which shell you use, but the other
+should be harmless.
+
+7) You should now be able to make and run e.g. main41 to produce HepMC 
+output files.
+
+------------------------------------------------------------------------
+
+Alternative B, with HepMC 2.04.02.
+
+1) Create a directory where you want to do the installation, e.g.
+     mkdir hepmc
+and move to it
+     cd hepmc
+
+2) Open
+     http://lcgapp.cern.ch/project/simu/HepMC/download 
+in a browser, scroll down to "HepMC 2.04.02" and 
+click on "source" rightmost on the line below.
+
+3) In the pop-up menu pick "Save to file" and then the above hepmc directory.
+You should now have a file "HepMC-2.04.02.tar.gz" in that directory.
+
+4) Unpack with
+    tar -xzf HepMC-2.04.02.tar.gz
+
+5) Create two new subdirectories
+    mkdir build install
+and move to build
+    cd build
+  
+6) Configure the compilation with
+    ../HepMC-2.04.02/configure -prefix=mypath/hepmc/install -with-momentum=GEV -with-length=MM
+all on one line, where "mypath" is the absolute path to the hepmc directory 
+(use pwd if in doubt).  
+
+7) Compile and install with
+     make
+     make check
+     make install
+which takes a minute or two and an amount of output. 
+
+8) Now move to your pythia8160 (or later) directory and configure with
+     ./configure --with-hepmc=mypath/hepmc/install --with-hepmcversion=2.04.02
+   (Re)compile with "make" (or "gmake") as usual.
+
+9) Move to the examples subdirectory and do
+     source config.sh
+     source config.csh
+Only one of them will work, depending on which shell you use, but the other
+should be harmless.
+
+10) You should now be able to make and run e.g. main41 to produce HepMC 
+output files (you can ignore compilation warnings about variables being 
+shadowed; this is harmless).
+
+NOTE: HepMC 2.04 allows you to set the units of the event record,
+i.e. to ensure that the Pythia default choice of GeV and mm (with c = 1)
+is propagated to the HepMC event record. This feature is not available
+in 2.03. The two test programs main31 and main32 therefore come with
+the Units code commented out, but with instructions how to restore it.  
diff --git a/PYTHIA8/pythia8170/README.Win32 b/PYTHIA8/pythia8170/README.Win32
new file mode 100644 (file)
index 0000000..9d68cce
--- /dev/null
@@ -0,0 +1,43 @@
+====================================
+   INSTRUCTIONS FOR WINDOWS USERS
+====================================
+
+I)   How to build
+II)  How to clean
+
+Note: this is a first version, and does not (yet) have
+the full functionality offered for the Linux case.
+
+I) How to build
+===============
+
+To build Pythia8 on windows, open a command prompt, 
+cd to the location where Pythia has been extracted, 
+then type nmake with any of these options :
+
+to build in debug mode :
+
+   nmake -f Makefile.msc CFG="Win32 Debug"
+
+in optimized mode :
+
+   nmake -f Makefile.msc CFG="Win32 Release"
+
+libPythia8.lib will be located in $PYTHIADIR\lib directory
+
+
+II) How to clean
+===============
+
+To clean intermediate (obj) files :
+
+   nmake -f Makefile.msc clean CFG="Win32 Debug"
+or
+   nmake -f Makefile.msc clean CFG="Win32 Release"
+
+To clean all binaries (obj, idb, pdb, ilk, lib and exe) :
+
+   nmake -f Makefile.msc distclean CFG="Win32 Debug"
+or
+   nmake -f Makefile.msc distclean CFG="Win32 Release"
+
diff --git a/PYTHIA8/pythia8170/configure b/PYTHIA8/pythia8170/configure
new file mode 100755 (executable)
index 0000000..1d488c4
--- /dev/null
@@ -0,0 +1,416 @@
+#!/bin/sh
+#
+# Configuration script, to be run before compilation
+#
+# Author: M. Kirsanov
+
+if [ x$BASH_VERSION = x ]; then
+  echo warning: you are not using bash shell on which this script is tested
+fi
+
+#
+# User-changeable part -------------------------------
+#
+
+#LCG platform. Can be needed if external libraries are specified
+if [ x$MYLCGPLATFORM = x ]; then
+  export MYLCGPLATFORM=x86_64-slc5-gcc43-opt
+fi
+
+# Defaults
+export COMPMODE=OPT
+export SHAREDLIBS=no
+export ENABLEGZIP=no
+export INSTALLDIR=.
+export DATADIR=
+
+for arg in $* ; do
+  if [ "x$arg" = "x--enable-debug" ] ; then
+    COMPMODE=DBG
+  elif [ "x$arg" = "x--enable-shared" ] ; then
+    SHAREDLIBS=yes
+  elif [ "x$arg" = "x--enable-64bits" ] ; then
+    ENABLE64=-m64
+  elif [ "x$arg" = "x--enable-gzip" ] ; then
+    ENABLEGZIP=yes
+  elif [ "x$arg" = "x--help" ] ; then
+    echo "Usage: ./configure [options] , where options are:"
+    echo "--help                : prints this help"
+    echo "--enable-debug        : turns on debugging flags and turns off optimization"
+    echo "--enable-shared       : turns on shared library creation (default no)"
+    echo "--enable-64bits       : turns on 64 bits compilation flags"
+    echo "--lcgplatform=name    : LCG platform name, default is x86_64-slc5-gcc43-opt"
+    echo "--installdir=name     : install directory, default is . "
+    echo "--prefix=name         : install directory (equivalent to --installdir)"
+    echo "--datadir=name        : data directory (for xmldoc), default is install directory"
+    echo "--with-hepmc=path     : path to HepMC library to build interface (default is not build)"
+    echo "--with-hepmcversion=v : HepMC version (simplified alternative when using CERN AFS LCG external, e.g. =2.04.00)"
+    echo "--enable-gzip         : turns on support for reading in gzipped files (default no)"
+    echo "                        (experimental feature, see README for more details)"
+    echo "--with-boost=path     : path to boost installation (default /usr) (required for gzip support)"
+    echo "--with-zlib=path      : path to zlib (default /usr/lib) (required for gzip support)"
+    echo
+    echo "Use the following environment variables to force the configuration process or add flags:"
+    echo "USRCXXFLAGS - to add flags. Use this variable to add -fPIC to the compilation flags for the static libraries"
+    echo "USRLDFLAGSSHARED - to add flags to the shared library build command"
+    echo "USRSHAREDSUFFIX - to force shared libraries suffix to be like this (default on MacOSX is dylib)"
+    echo
+    exit
+  elif [ x`echo x${arg} | grep "="` != x ] ; then
+    option=`echo ${arg} | awk -F = '{print $1}'`
+    value=`echo ${arg} | awk -F = '{print $2}'`
+    if [ "x${option}" = "x--lcgplatform" ] ; then
+      MYLCGPLATFORM=${value}
+    elif [ "x${option}" = "x--installdir" ] ; then
+      INSTALLDIR=${value}
+    elif [ "x${option}" = "x--prefix" ] ; then
+      INSTALLDIR=${value}
+    elif [ "x${option}" = "x--datadir" ] ; then
+      DATADIR=${value}
+    elif [ "x${option}" = "x--with-hepmcversion" ] ; then
+      HEPMCVERSION=${value}
+    elif [ "x${option}" = "x--with-hepmc" ] ; then
+      HEPMCLOCATION=${value}
+    elif [ "x${option}" = "x--with-boost" ] ; then
+      BOOSTLOCATION=${value}
+    elif [ "x${option}" = "x--with-zlib" ] ; then
+      ZLIBLOCATION=${value}
+    else
+      echo "${arg}: wrong option. Ignored." >&2
+    fi
+  fi
+done
+
+echo compilation mode is $COMPMODE
+echo sharedlibs = $SHAREDLIBS
+
+if [ "x${DATADIR}" = "x" ] ; then
+  DATADIR=${INSTALLDIR}
+fi
+
+# Environment variables for building HepMC interface library. Note that
+# the HepMC interface library is used by the examples main41, main42, ..  .
+# Attention: if you have already run these examples and you change HepMC
+# version you should reset your LD_LIBRARY_PATH
+# The default values here correspond to CERN AFS lcg external
+#
+if [ "x${HEPMCVERSION}" != "x" ] ; then
+  if [ "x${HEPMCLOCATION}" = "x" ] ; then
+    export HEPMCLOCATION=/afs/cern.ch/sw/lcg/external/HepMC/${HEPMCVERSION}/${MYLCGPLATFORM}
+  fi
+fi
+#   If you want to assign these variables by hand:
+#
+#export HEPMCVERSION=2.04.00
+#export HEPMCLOCATION=/afs/cern.ch/sw/lcg/external/HepMC/${HEPMCVERSION}/${MYLCGPLATFORM}
+
+
+if [ "x${HEPMCVERSION}" = "x" ] ; then
+  if [ "x${HEPMCLOCATION}" != "x" ] ; then
+#                                            try to find out which HepMC version
+    test1=`echo $HEPMCLOCATION | grep \/1.`
+    test2=`echo $HEPMCLOCATION | grep \/2.`
+    echo $test1
+    echo $test2
+    if [ "x${test1}" != "x" ] ; then
+      echo "Warning: HepMC 1 cannot be used anymore; Please use HepMC 2"
+      echo "         The interface will not be built"
+      export HEPMCLOCATION=
+    fi
+    if [ "x${test2}" != "x" ] ; then
+      export HEPMCVERSION=2.`echo $HEPMCLOCATION | awk -F \/2. '{print $2}' | awk -F \/ '{print $1}'`
+    fi
+  fi
+fi
+if [ "x${HEPMCVERSION}" != "x" ] ; then
+  export HEPMCMAINVERSION=`echo ${HEPMCVERSION} | awk -F . '{print$1}'`
+  if [ ${HEPMCMAINVERSION} = 1 ] ; then
+    echo "Warning: HepMC 1 cannot be used anymore; Please use HepMC 2"
+    echo "         The interface will not be built"
+    export HEPMCLOCATION=
+  fi
+fi
+if [ "x${HEPMCLOCATION}" != "x" ] ; then
+  if [ "x${HEPMCVERSION}" = "x" ] ; then
+    echo "Warning: hepmc specified, but cannot find out which HepMC version"
+    echo "Warning: if you specify HepMC 1 the compilation of interface will fail"
+  fi
+fi
+
+
+#
+# User-changeable part, experts  -----------------------------
+#
+
+# Switch off -Wshadow when gzip support is enabled
+WSHADOW="-Wshadow"
+if [ "x${ENABLEGZIP}" = "xyes" ]; then
+  WSHADOW=""
+fi
+
+# export FFLAGS_OPT="-O2 -Wuninitialized"
+# -Wuninitialized outputs many irrelevant warnings and therefore obscurs 
+export FFLAGS_OPT="-O2"
+export FFLAGS_DBG=-g
+export CFLAGS_OPT="-O2"
+export CFLAGS_DBG=-g
+export CXXFLAGS_OPT="-O2 -ansi -pedantic -W -Wall ${WSHADOW} ${ENABLE64}"
+export CXXFLAGS_DBG="-g -ansi -pedantic -W -Wall ${WSHADOW} ${ENABLE64}"
+#
+# Find platform.
+#
+export ARCH0="`uname`"
+export ARCH=${ARCH0}
+export theGcc=`gcc -dumpversion | awk -F . '{print $1}'`
+if [ ${theGcc} = 4 ]; then
+  export ARCH=${ARCH}-gcc4
+fi
+echo Platform is $ARCH
+
+#default platform settings:
+export FC=g77
+export CC=gcc
+export FFLAGS="${FFLAGS_OPT}"
+export CFLAGS="${CFLAGS_OPT}"
+export CXXFLAGS="${CXXFLAGS_OPT}"
+export FLIBS="-lfrtbegin -lg2c"
+if [ ${COMPMODE} = OPT ]; then
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+fi
+if [ ${COMPMODE} = DBG ]; then
+  export FFLAGS="${FFLAGS_DBG}"
+  export CFLAGS="${CFLAGS_DBG}"
+  export CXXFLAGS="${CXXFLAGS_DBG}"
+fi
+LDFLAGSSHARED="${CXXFLAGS} -fPIC -shared"
+LDFLAGLIBNAME="-Wl,-soname"
+SHAREDSUFFIX=so
+if [ $ARCH = Linux ]; then
+  export FC=g77
+  export FFLAGS="${FFLAGS_OPT} -Wno-globals"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lfrtbegin -lg2c"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG} -Wno-globals"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+  LDFLAGSSHARED="${CXXFLAGS} -fPIC -shared"
+  LDFLAGLIBNAME="-Wl,-soname"
+  SHAREDSUFFIX=so
+fi
+# Linux platform with gcc4: new Fortran90 compiler.
+if [ $ARCH = Linux-gcc4 ]; then
+  export FC=gfortran
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lgfortran -lgfortranbegin"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+  LDFLAGSSHARED="${CXXFLAGS} -fPIC -shared"
+  LDFLAGLIBNAME="-Wl,-soname"
+  SHAREDSUFFIX=so
+fi
+# Mac-OSX with gcc4
+if [ $ARCH = Darwin-gcc4 ]; then
+  export FC=gfortran
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lgfortran"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+  LDFLAGSSHARED="${CXXFLAGS} -dynamiclib -single_module -flat_namespace -undefined suppress"
+  LDFLAGLIBNAME="-Wl,-dylib_install_name"
+  SHAREDSUFFIX=dylib
+fi
+# Mac-OSX with gcc3; is not tested
+if [ $ARCH = Darwin ]; then
+  export FC=g77
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lfrtbegin -lg2c"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+  LDFLAGSSHARED="${CXXFLAGS} -dynamiclib -single_module -flat_namespace -undefined suppress"
+  LDFLAGLIBNAME="-Wl,-dylib_install_name"
+  SHAREDSUFFIX=dylib
+fi
+
+
+CXXFLAGS="${CXXFLAGS} $USRCXXFLAGS"
+LDFLAGSSHARED="${LDFLAGSSHARED} $USRLDFLAGSSHARED"
+if [ "x${USRSHAREDSUFFIX}" != "x" ] ; then
+  SHAREDSUFFIX="${USRSHAREDSUFFIX}"
+fi
+
+
+#Platform & opt/dbg - independent flags and variables:
+
+
+#
+# End of the user-changeable part ---------------------------
+#
+# Checks
+#
+if [ $?HEPMCLOCATION ]; then
+  if [ x${HEPMCLOCATION} != x ]; then
+    if [ ! -d ${HEPMCLOCATION}/include ]; then
+      echo "Warning: bad HEPMCLOCATION: directory ${HEPMCLOCATION}/include does not exist"
+      echo "         The interface will not be built"
+      export HEPMCLOCATION=
+    fi
+    if [ ! -d ${HEPMCLOCATION}/lib ]; then
+      echo "Warning: bad HEPMCLOCATION: directory ${HEPMCLOCATION}/lib does not exist"
+      echo "         The interface will not be built"
+      export HEPMCLOCATION=
+    fi
+  fi
+fi
+
+# gzip support - do after SHAREDSUFFIX is set
+if [ "x${ENABLEGZIP}" = "xyes" ]; then
+
+  # Default locations if none given
+  if [ "x${BOOSTLOCATION}" = "x" ]; then
+    BOOSTLOCATION=/usr
+  fi
+  if [ "x${ZLIBLOCATION}" = "x" ]; then
+    ZLIBLOCATION=/usr/lib
+  fi
+
+  # Check for Boost and zlib
+  if [ "x${ENABLEGZIP}" = "xyes" ] ; then
+    if [ ! -d "${BOOSTLOCATION}/include/boost/iostreams" ]; then
+      echo "Error: cannot find required Boost include files; gzip support disabled"
+      ENABLEGZIP=no
+    fi
+
+    # Some systems have Boost only under lib64?
+    for i in lib lib64; do 
+      if [ -f "${BOOSTLOCATION}/$i/libboost_iostreams.${SHAREDSUFFIX}" ]; then
+        BOOSTLIBLOCATION=${BOOSTLOCATION}/$i
+        break
+      fi
+    done
+
+    if [ "x${ENABLEGZIP}" = "xyes" -a x"${BOOSTLIBLOCATION}" = x ]; then
+      echo "Error: cannot find required Boost library files; gzip support disabled"
+      ENABLEGZIP=no
+    fi
+
+    if [ "x${ENABLEGZIP}" = "xyes" -a ! -f "${ZLIBLOCATION}/libz.${SHAREDSUFFIX}" ]; then
+      echo "Error: cannot find zlib; gzip support disabled"
+      ENABLEGZIP=no
+    fi
+  fi
+
+  # Add flags
+  if [ "x${ENABLEGZIP}" = "xyes" ] ; then
+    echo gzip support is enabled
+    CXXFLAGS="${CXXFLAGS} -DGZIPSUPPORT -I${BOOSTLOCATION}/include"
+  fi
+fi
+
+rm -f config.mk
+
+echo SHELL = /bin/sh > config.mk
+echo ARCH = ${ARCH} >> config.mk
+echo MYLCGPLATFORM = ${MYLCGPLATFORM} >> config.mk
+echo SHAREDLIBS = ${SHAREDLIBS} >> config.mk
+echo FC = ${FC} >> config.mk
+echo CC = ${CC} >> config.mk
+echo FFLAGS = ${FFLAGS} >> config.mk
+echo CFLAGS = ${CFLAGS} >> config.mk
+echo CXXFLAGS = ${CXXFLAGS} >> config.mk
+echo FLIBS = ${FLIBS} >> config.mk
+echo LDFLAGSSHARED = ${LDFLAGSSHARED} >> config.mk
+echo LDFLAGLIBNAME = ${LDFLAGLIBNAME} >> config.mk
+echo SHAREDSUFFIX = ${SHAREDSUFFIX} >> config.mk
+echo INSTALLDIR = ${INSTALLDIR} >> config.mk
+echo DATADIR = ${DATADIR} >> config.mk
+#
+if [ x${HEPMCLOCATION} != x ]; then
+  if [ x${HEPMCVERSION} != x ]; then
+    echo HEPMCVERSION = ${HEPMCVERSION} >> config.mk
+  fi
+  echo HEPMCLOCATION = ${HEPMCLOCATION} >> config.mk
+fi
+#
+#
+#
+rm -f examples/config.sh
+rm -f examples/config.csh
+if [ x${HEPMCLOCATION} != x ]; then
+  if [ $ARCH0 != Darwin ]; then
+    echo "#!/bin/csh" > examples/config.csh
+    echo 'if( ! $?LD_LIBRARY_PATH ) then' >> examples/config.csh
+    echo "  setenv LD_LIBRARY_PATH ${HEPMCLOCATION}/lib" >> examples/config.csh
+    echo "else" >> examples/config.csh
+    echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${HEPMCLOCATION}/lib" >> examples/config.csh
+    echo "endif" >> examples/config.csh
+    echo "#!/bin/sh" > examples/config.sh
+    echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> examples/config.sh
+    echo "  export LD_LIBRARY_PATH=${HEPMCLOCATION}/lib" >> examples/config.sh
+    echo fi >> examples/config.sh
+    echo 'if [ $?LD_LIBRARY_PATH ]; then' >> examples/config.sh
+    echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${HEPMCLOCATION}/lib" >> examples/config.sh
+    echo fi >> examples/config.sh
+  else
+    echo "#!/bin/csh" > examples/config.csh
+    echo 'if( ! $?DYLD_LIBRARY_PATH ) then' >> examples/config.csh
+    echo "  setenv DYLD_LIBRARY_PATH ${HEPMCLOCATION}/lib" >> examples/config.csh
+    echo "else" >> examples/config.csh
+    echo "  setenv DYLD_LIBRARY_PATH" '${DYLD_LIBRARY_PATH}'":${HEPMCLOCATION}/lib" >> examples/config.csh
+    echo "endif" >> examples/config.csh
+    echo "#!/bin/sh" > examples/config.sh
+    echo 'if [ ! $?DYLD_LIBRARY_PATH ]; then' >> examples/config.sh
+    echo "  export DYLD_LIBRARY_PATH=${HEPMCLOCATION}/lib" >> examples/config.sh
+    echo fi >> examples/config.sh
+    echo 'if [ $?DYLD_LIBRARY_PATH ]; then' >> examples/config.sh
+    echo "  export DYLD_LIBRARY_PATH="'${DYLD_LIBRARY_PATH}'":${HEPMCLOCATION}/lib" >> examples/config.sh
+    echo fi >> examples/config.sh
+  fi
+fi
+
+# gzip support - write locations into config.mk
+if [ "x${ENABLEGZIP}" = "xyes" ] ; then
+  echo "ENABLEGZIP = yes" >> config.mk
+  echo "BOOSTLOCATION = ${BOOSTLOCATION}" >> config.mk
+  echo "BOOSTLIBLOCATION = ${BOOSTLIBLOCATION}" >> config.mk
+  echo "ZLIBLOCATION = ${ZLIBLOCATION}" >> config.mk
+fi
diff --git a/PYTHIA8/pythia8170/examples/LHAupAlpgen.h b/PYTHIA8/pythia8170/examples/LHAupAlpgen.h
new file mode 100644 (file)
index 0000000..c30d2d6
--- /dev/null
@@ -0,0 +1,1071 @@
+// LHAupAlpgen.h is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Author: Richard Corke (richard.corke@thep.lu.se)
+// This file provides the following classes:
+//   AlpgenPar:   a class for parsing ALPGEN parameter files
+//                and reading back out the values
+//   LHAupAlpgen: an LHAup derived class for reading in ALPGEN
+//                format event files
+//   AlpgenHooks: a UserHooks derived class for providing
+//                'Alpgen:*' user options
+// Example usage is shown in main32.cc, and further details
+// can be found in the 'Alpgen and MLM Merging' manual page.
+
+#ifndef LHAUPALPGEN_H
+#define LHAUPALPGEN_H
+
+// Includes and namespace
+#include "Pythia.h"
+using namespace Pythia8;
+
+//==========================================================================
+
+// Preprocessor settings
+
+// Debug flag to print all particles in each event
+//#define LHADEBUG
+// Debug flag to print particles when an e/p imbalance is found
+//#define LHADEBUGRESCALE
+
+//==========================================================================
+
+// AlpgenPar: Class to parse ALPGEN parameter files and make them
+//            available through a simple interface
+
+class AlpgenPar {
+
+public:
+
+  // Constructor
+  AlpgenPar(Info *infoPtrIn = NULL) : infoPtr(infoPtrIn) {}
+
+  // Parse as incoming ALPGEN parameter file (passed as string)
+  bool parse(const string paramStr);
+
+  // Parse an incoming parameter line
+  void extractRunParam(string line);
+
+  // Check if a parameter exists
+  bool haveParam(const string &paramIn) {
+    return (params.find(paramIn) == params.end()) ? false : true; }
+
+  // Get a parameter as a double or integer.
+  // Caller should have already checked existance of the parameter.
+  double getParam(const string &paramIn) {
+    return (haveParam(paramIn)) ? params[paramIn] : 0.; }
+  int    getParamAsInt(const string &paramIn) {
+    return (haveParam(paramIn)) ? int(params[paramIn]) : 0.; }
+
+  // Print parameters read from the '.par' file
+  void printParams();
+
+private:
+
+  // Warn if a parameter is going to be overwriten
+  void warnParamOverwrite(const string &paramIn, double val);
+
+  // Simple string trimmer
+  static string trim(string s);
+
+  // Storage for parameters
+  map < string, double > params;
+
+  // Info pointer if provided
+  Info *infoPtr;
+
+  // Constants
+  static const double ZEROTHRESHOLD;
+
+};
+
+//--------------------------------------------------------------------------
+
+// Main implementation of AlpgenPar class. This may be split out to a
+// separate C++ file if desired, but currently included here for ease
+// of use.
+
+// Constants: could be changed here if desired, but normally should not.
+// These are of technical nature, as described for each.
+
+// A zero threshold value for double comparisons.
+const double AlpgenPar::ZEROTHRESHOLD = 1e-10;
+
+//--------------------------------------------------------------------------
+
+// Warn if e/pT imbalance greater than these values
+// Parse an incoming Alpgen parameter file string
+
+bool AlpgenPar::parse(const string paramStr) {
+
+  // Read par file in blocks:
+  //   0 - process information
+  //   1 - run parameters
+  //   2 - cross sections
+  int block = 0;
+
+  // Loop over incoming lines
+  stringstream paramStream(paramStr);
+  string line;
+  while (getline(paramStream, line)) {
+
+    // Change to 'run parameters' block
+    if        (line.find("run parameters") != string::npos) {
+      block = 1;
+
+    // End of 'run parameters' block
+    } else if (line.find("end parameters") != string::npos) {
+      block = 2;
+
+    // Do not extract anything from block 0 so far
+    } else if (block == 0) {
+
+    // Block 1 or 2: extract parameters
+    } else {
+      extractRunParam(line);
+
+    }
+  } // while (getline(paramStream, line))
+
+  return true;
+}
+
+//--------------------------------------------------------------------------
+
+// Parse an incoming parameter line
+
+void AlpgenPar::extractRunParam(string line) {
+
+  // Extract information to the right of the final '!' character
+  size_t idx = line.rfind("!");
+  if (idx == string::npos) return;
+  string paramName = trim(line.substr(idx + 1));
+  string paramVal  = trim(line.substr(0, idx));
+  istringstream iss(paramVal);
+
+  // Special case: 'hard process code' - single integer input
+  double val;
+  if (paramName == "hard process code") {
+    iss >> val;
+    warnParamOverwrite("hpc", val);
+    params["hpc"] = val;
+
+  // Special case: 'Crosssection +- error (pb)' - two double values
+  } else if (paramName.find("Crosssection") == 0) {
+    double xerrup;
+    iss >> val >> xerrup;
+    warnParamOverwrite("xsecup", val);
+    warnParamOverwrite("xerrup", val);
+    params["xsecup"] = val;
+    params["xerrup"] = xerrup;
+
+  // Special case: 'unwtd events, lum (pb-1)' - integer and double values
+  } else if (paramName.find("unwtd events") == 0) {
+    int nevent;
+    iss >> nevent >> val;
+    warnParamOverwrite("nevent", val);
+    warnParamOverwrite("lum", val);
+    params["nevent"] = nevent;
+    params["lum"]    = val;
+
+  // Special case: 'mc,mb,...' - split on ',' for name and ' ' for values
+  } else if (paramName.find(",") != string::npos) {
+    
+    // Simple tokeniser
+    string        paramNameNow;
+    istringstream issName(paramName);
+    while (getline(issName, paramNameNow, ',')) {
+      iss >> val;
+      warnParamOverwrite(paramNameNow, val);
+      params[paramNameNow] = val;
+    }
+
+  // Default case: assume integer and double on the left
+  } else {
+    int paramIdx;
+    iss >> paramIdx >> val;
+    warnParamOverwrite(paramName, val);
+    params[paramName] = val;
+  }
+}
+
+//--------------------------------------------------------------------------
+
+// Print parameters read from the '.par' file
+
+void AlpgenPar::printParams() {
+
+  // Loop over all stored parameters and print
+  cout << fixed << setprecision(3) << endl
+       << " *-------  Alpgen parameters  -------*" << endl;
+  for (map < string, double >::iterator it = params.begin();
+       it != params.end(); ++it)
+    cout << " |  " << left << setw(13) << it->first
+         << "  |  " << right << setw(13) << it->second
+         << "  |" << endl;
+  cout << " *-----------------------------------*" << endl;
+}
+
+//--------------------------------------------------------------------------
+
+// Warn if a parameter is going to be overwriten
+
+void AlpgenPar::warnParamOverwrite(const string &paramIn, double val) {
+
+  // Check if present and if new value is different
+  if (haveParam(paramIn) &&
+      abs(getParam(paramIn) - val) > ZEROTHRESHOLD) {
+    if (infoPtr) infoPtr->errorMsg("Warning in LHAupAlpgen::"
+        "warnParamOverwrite: overwriting existing parameter", paramIn);
+  }
+}
+
+//--------------------------------------------------------------------------
+
+// Simple string trimmer
+
+string AlpgenPar::trim(string s) {
+
+  // Remove whitespace in incoming string
+  size_t i;
+  if ((i = s.find_last_not_of(" \t\r\n")) != string::npos)
+    s = s.substr(0, i + 1);
+  if ((i = s.find_first_not_of(" \t\r\n")) != string::npos)
+    s = s.substr(i);
+  return s;
+}
+
+//==========================================================================
+
+// LHAupAlpgen: LHAup derived class for reading in ALPGEN format
+//              event files.
+
+class LHAupAlpgen : public LHAup {
+
+public:
+
+  // Constructor and destructor.
+  LHAupAlpgen(const char *baseFNin, Info *infoPtrIn = NULL);
+  ~LHAupAlpgen() { closeFile(isUnw, ifsUnw); }
+
+  // Override fileFound routine from LHAup.
+  bool fileFound() { return (isUnw != NULL); }
+
+  // Override setInit/setEvent routines from LHAup.
+  bool setInit();
+  bool setEvent(int);
+
+  // Print list of particles; mainly intended for debugging
+  void printParticles();
+
+private:
+
+  // Add resonances to incoming event.
+  bool addResonances();
+
+  // Rescale momenta to remove any imbalances.
+  bool rescaleMomenta();
+
+  // Class variables
+  string    baseFN, parFN, unwFN;  // Incoming filenames
+  AlpgenPar alpgenPar;             // Parameter database
+
+  int      lprup;                  // Process code
+  double   ebmupA, ebmupB;         // Beam energies
+  int      ihvy1, ihvy2;           // Heavy flavours for certain processes
+  double   mb;                     // Bottom mass
+
+  ifstream  ifsUnw;                // Input file stream for 'unw' file
+  istream  *isUnw;                 // Input stream for 'unw' file
+
+  vector < LHAParticle > myParticles;  // Local storage for particles
+
+  // Constants
+  static const double ZEROTHRESHOLD, EWARNTHRESHOLD, PTWARNTHRESHOLD,
+                      INCOMINGMIN;
+};
+
+// ----------------------------------------------------------------------
+
+// Main implementation of LHAupAlpgen class. This may be split out to a
+// separate C++ file if desired, but currently included here for ease
+// of use.
+
+// Constants: could be changed here if desired, but normally should not.
+// These are of technical nature, as described for each.
+
+// A zero threshold value for double comparisons.
+const double LHAupAlpgen::ZEROTHRESHOLD   = 1e-10;
+
+// Warn if e/pT imbalance greater than these values
+const double LHAupAlpgen::EWARNTHRESHOLD  = 3e-3;
+const double LHAupAlpgen::PTWARNTHRESHOLD = 1e-3;
+
+// If incoming e/pZ is 0, it is reset to this value
+const double LHAupAlpgen::INCOMINGMIN     = 1e-3;
+
+// ----------------------------------------------------------------------
+
+// Constructor. Opens parameter file and parses then opens event file.
+
+LHAupAlpgen::LHAupAlpgen(const char *baseFNin, Info *infoPtrIn)
+    : baseFN(baseFNin), alpgenPar(infoPtrIn), isUnw(NULL) {
+
+  // Set the info pointer if given
+  if (infoPtrIn) setPtr(infoPtrIn);
+
+  // Read in '_unw.par' file to get parameters
+  ifstream  ifsPar;
+  istream  *isPar = NULL;
+
+  // Try gzip file first then normal file afterwards
+#ifdef GZIPSUPPORT
+  parFN = baseFN + "_unw.par.gz";
+  isPar = openFile(parFN.c_str(), ifsPar);
+  if (!ifsPar.is_open()) closeFile(isPar, ifsPar);
+#endif
+  if (isPar == NULL) {
+    parFN = baseFN + "_unw.par";
+    isPar = openFile(parFN.c_str(), ifsPar);
+    if (!ifsPar.is_open()) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::LHAupAlpgen: "
+          "cannot open parameter file", parFN);
+      closeFile(isPar, ifsPar);
+      return;
+    }
+  }
+
+  // Read entire contents into string and close file
+  string paramStr((istreambuf_iterator<char>(isPar->rdbuf())),
+                   istreambuf_iterator<char>());
+
+  // Make sure we reached EOF and not other error
+  if (ifsPar.bad()) {
+    if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::LHAupAlpgen: "
+        "cannot read parameter file", parFN);
+    return;
+  }
+  closeFile(isPar, ifsPar);
+
+  // Parse file and set LHEF header
+  alpgenPar.parse(paramStr);
+  if (infoPtr) setInfoHeader("AlpgenPar", paramStr);
+
+  // Open '.unw' events file (with possible gzip support)
+#ifdef GZIPSUPPORT
+  unwFN = baseFN + ".unw.gz";
+  isUnw = openFile(unwFN.c_str(), ifsUnw);
+  if (!ifsUnw.is_open()) closeFile(isUnw, ifsUnw);
+#endif
+  if (isUnw == NULL) {
+    unwFN = baseFN + ".unw";
+    isUnw = openFile(unwFN.c_str(), ifsUnw);
+    if (!ifsUnw.is_open()) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::LHAupAlpgen: "
+          "cannot open event file", unwFN);
+      closeFile(isUnw, ifsUnw);
+    }
+  }
+}
+
+// ----------------------------------------------------------------------
+
+// setInit is a virtual method that must be finalised here.
+// Sets up beams, strategy and processes.
+
+bool LHAupAlpgen::setInit() {
+
+  // Check that all required parameters are present
+  if (!alpgenPar.haveParam("ih2") || !alpgenPar.haveParam("ebeam")  ||
+      !alpgenPar.haveParam("hpc") || !alpgenPar.haveParam("xsecup") ||
+      !alpgenPar.haveParam("xerrup")) {
+    if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setInit: "
+        "missing input parameters");
+    return false;
+  }
+
+  // Beam IDs
+  int ih2 = alpgenPar.getParamAsInt("ih2");
+  int idbmupA = 2212;
+  int idbmupB = (ih2 == 1) ? 2212 : -2212;
+
+  // Beam energies
+  double ebeam = alpgenPar.getParam("ebeam");
+  ebmupA = ebeam;
+  ebmupB = ebmupA;
+
+  // PDF group and set (at the moment not set)
+  int pdfgupA = 0, pdfsupA = 0;
+  int pdfgupB = 0, pdfsupB = 0;
+
+  // Strategy is for unweighted events and xmaxup not important
+  int    idwtup = 3;
+  double xmaxup = 0.;
+
+  // Get hard process code
+  lprup = alpgenPar.getParamAsInt("hpc");
+
+  // Check for unsupported processes
+  if (lprup == 7 || lprup == 8 || lprup == 13) {
+    if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setInit: "
+        "process not implemented");
+    return false;
+  }
+
+  // Depending on the process code, get heavy flavour information:
+  //    6 = QQbar           + jets
+  //    7 = QQbar + Q'Qbar' + jets
+  //    8 = QQbar + Higgs   + jets
+  //   16 = QQbar + gamma   + jets
+  if (lprup == 6 || lprup == 7 || lprup == 8 || lprup == 16) {
+    if (!alpgenPar.haveParam("ihvy")) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setInit: "
+          "heavy flavour information not present");
+      return false;
+    }
+    ihvy1 = alpgenPar.getParamAsInt("ihvy");
+
+  } else ihvy1 = -1;
+  if (lprup == 7) {
+    if (!alpgenPar.haveParam("ihvy2")) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setInit: "
+          "heavy flavour information not present");
+      return false;
+    }
+    ihvy2 = alpgenPar.getParamAsInt("ihvy2");
+  } else ihvy2 = -1;
+  // For single top (process 13), get b mass to set incoming
+  mb = -1.;
+  if (lprup == 13) {
+    if (!alpgenPar.haveParam("mb")) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setInit: "
+          "heavy flavour information not present");
+      return false;
+    }
+    mb = alpgenPar.getParam("mb");
+  }
+
+  // Set the beams
+  setBeamA(idbmupA, ebmupA, pdfgupA, pdfsupA);
+  setBeamB(idbmupB, ebmupB, pdfgupB, pdfsupB);
+  setStrategy(idwtup);
+
+  // Add the process
+  double xsecup = alpgenPar.getParam("xsecup");
+  double xerrup = alpgenPar.getParam("xerrup");
+  addProcess(lprup, xsecup, xerrup, xmaxup);
+  xSecSumSave = xsecup;
+  xErrSumSave = xerrup;
+
+  // All okay
+  return true; 
+}
+
+// ----------------------------------------------------------------------
+
+// setEvent is a virtual method that must be finalised here.
+// Read in an event from the 'unw' file and setup.
+
+bool LHAupAlpgen::setEvent(int) {
+
+  // Read in the first line of the event
+  int    nEvent, iProc, nParton;
+  double Swgt, Sq;
+  string line;
+  if (!getline(*isUnw, line)) {
+    // Read was bad
+    if (ifsUnw.bad()) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setEvent: "
+          "could not read events from file");
+      return false;
+    }
+    // End of file reached
+    if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setEvent: "
+        "end of file reached");
+    return false;
+  }
+  istringstream iss1(line);
+  iss1 >> nEvent >> iProc >> nParton >> Swgt >> Sq;
+
+  // Set the process details (ignore alphaQED and alphaQCD parameters)
+  double wgtT = Swgt, scaleT = Sq;
+  setProcess(lprup, wgtT, scaleT);
+
+  // Incoming flavour and x information for later
+  int    id1T, id2T;
+  double x1T, x2T;
+  // Temporary storage for read in parton information
+  int    idT, statusT, mother1T, mother2T, col1T, col2T;
+  double pxT, pyT, pzT, eT, mT;
+  // Leave tau and spin as default values
+  double tauT = 0., spinT = 9.;
+
+  // Store particles locally at first so that resonances can be added
+  myParticles.clear();
+
+  // Now read in partons
+  for (int i = 0; i < nParton; i++) {
+    // Get the next line
+    if (!getline(*isUnw, line)) {
+      if (infoPtr) infoPtr->errorMsg("Error in LHAupAlpgen::setEvent: "
+          "could not read events from file");
+      return false;
+    }
+    istringstream iss2(line);
+
+    // Incoming (flavour, colour, anticolour, pz)
+    if (i < 2) {
+      // Note that mothers will be set automatically by Pythia, and LHA
+      // status -1 is for an incoming parton
+      iss2 >> idT >> col1T >> col2T >> pzT;
+      statusT  = -1;
+      mother1T = mother2T = 0;
+      pxT = pyT = mT = 0.;
+      eT  = abs(pzT);
+
+      // Adjust when zero pz/e
+      if (pzT == 0.) {
+        pzT = (i == 0) ? INCOMINGMIN : -INCOMINGMIN;
+        eT  = INCOMINGMIN;
+      }
+
+    // Outgoing (flavour, colour, anticolour, px, py, pz, mass)
+    } else {
+      // Note that mothers 1 and 2 corresport to the incoming partons,
+      // as set above, and LHA status +1 is for outgoing final state
+      iss2 >> idT >> col1T >> col2T >> pxT >> pyT >> pzT >> mT;
+      statusT  = 1;
+      mother1T = 1;
+      mother2T = 2;
+      eT = sqrt(max(0., pxT*pxT + pyT*pyT + pzT*pzT + mT*mT));
+    }
+
+    // Add particle
+    myParticles.push_back(LHAParticle(
+        idT, statusT, mother1T, mother2T, col1T, col2T,
+        pxT, pyT, pzT, eT, mT, tauT, spinT));
+  }
+
+  // Add resonances if required
+  if (!addResonances()) return false;
+
+  // Rescale momenta if required (must be done after full event
+  // reconstruction in addResonances)
+  if (!rescaleMomenta()) return false;
+
+  // Pass particles on to Pythia
+  for (size_t i = 0; i < myParticles.size(); i++)
+    addParticle(myParticles[i]);
+
+  // Set incoming flavour/x information and done
+  id1T = myParticles[0].idPart;
+  x1T  = myParticles[0].ePart / ebmupA;
+  id2T = myParticles[1].idPart;
+  x2T  = myParticles[1].ePart / ebmupA;
+  setIdX(id1T, id2T, x1T, x2T);
+  setPdf(id1T, id2T, x1T, x2T, 0., 0., 0., false);
+  return true;
+}
+
+// ----------------------------------------------------------------------
+
+// Print list of particles; mainly intended for debugging
+
+void LHAupAlpgen::printParticles() {
+  cout << endl << "---- LHAupAlpgen particle listing begin ----" << endl;
+  cout << scientific << setprecision(6);
+  for (int i = 0; i < int(myParticles.size()); i++) {
+    cout << setw(5)  << i
+         << setw(5)  << myParticles[i].idPart
+         << setw(5)  << myParticles[i].statusPart
+         << setw(15) << myParticles[i].pxPart
+         << setw(15) << myParticles[i].pyPart
+         << setw(15) << myParticles[i].pzPart
+         << setw(15) << myParticles[i].ePart
+         << setw(15) << myParticles[i].mPart
+         << setw(5)  << myParticles[i].mother1Part - 1
+         << setw(5)  << myParticles[i].mother2Part - 1
+         << setw(5)  << myParticles[i].col1Part
+         << setw(5)  << myParticles[i].col2Part
+         << endl;
+  }
+  cout << "----  LHAupAlpgen particle listing end  ----" << endl;
+}
+
+// ----------------------------------------------------------------------
+
+// Routine to add resonances to an incoming event based on the
+// hard process code (now stored in lprup).
+
+bool LHAupAlpgen::addResonances() {
+
+  // Temporary storage for resonance information
+  int    idT, statusT, mother1T, mother2T, col1T, col2T;
+  double pxT, pyT, pzT, eT, mT;
+  // Leave tau and spin as default values
+  double tauT = 0., spinT = 9.;
+
+  // Alpgen process dependent parts. Processes:
+  //    1 = W        + QQbar         + jets
+  //    2 = Z/gamma* + QQbar         + jets
+  //    3 = W                        + jets
+  //    4 = Z/gamma*                 + jets
+  //   10 = W        + c             + jets
+  //   14 = W        + gamma         + jets
+  //   15 = W        + QQbar + gamma + jets
+  // When QQbar = ttbar, tops are not decayed in these processes.
+  // Explicitly reconstruct W/Z resonances; assumption is that the
+  // decay products are the last two particles.
+  if (lprup <= 4 || lprup == 10 || lprup == 14 || lprup == 15) {
+    // Decay products are the last two entries
+    int i1 = myParticles.size() - 1, i2 = i1 - 1;
+
+    // Follow 'alplib/alpsho.f' procedure to get ID
+    if (myParticles[i1].idPart + myParticles[i2].idPart == 0)
+      idT = 0;
+    else
+      idT = - (myParticles[i1].idPart % 2) - (myParticles[i2].idPart % 2);
+    idT = (idT > 0) ? 24 : (idT < 0) ? -24 : 23;
+
+    // Check that we get the expected resonance type; Z/gamma*
+    if (lprup == 2 || lprup == 4) {
+      if (idT != 23) {
+        if (infoPtr) infoPtr->errorMsg("Error in "
+            "LHAupAlpgen::addResonances: wrong resonance type in event");
+        return false;
+      }
+
+    // W's
+    } else {
+      if (abs(idT) != 24) {
+        if (infoPtr) infoPtr->errorMsg("Error in "
+            "LHAupAlpgen::addResonances: wrong resonance type in event");
+        return false;
+      }
+    }
+
+    // Remaining input
+    statusT  = 2;
+    mother1T = 1;
+    mother2T = 2;
+    col1T = col2T = 0;
+    pxT = myParticles[i1].pxPart + myParticles[i2].pxPart;
+    pyT = myParticles[i1].pyPart + myParticles[i2].pyPart;
+    pzT = myParticles[i1].pzPart + myParticles[i2].pzPart;
+    eT  = myParticles[i1].ePart  + myParticles[i2].ePart;
+    mT  = sqrt(eT*eT - pxT*pxT - pyT*pyT - pzT*pzT);
+    myParticles.push_back(LHAParticle(
+        idT, statusT, mother1T, mother2T, col1T, col2T,
+        pxT, pyT, pzT, eT, mT, tauT, spinT));
+
+    // Update decay product mothers (note array size as if from 1)
+    myParticles[i1].mother1Part = myParticles[i2].mother1Part =
+        myParticles.size();
+    myParticles[i1].mother2Part = myParticles[i2].mother2Part = 0;
+
+  // Processes:
+  //    5 = nW + mZ + j gamma + lH + jets
+  //    6 = QQbar         + jets    (QQbar = ttbar)
+  //    8 = QQbar + Higgs + jets    (QQbar = ttbar)
+  //   13 = top   + q               (topprc = 1)
+  //   13 = top   + b               (topprc = 2)
+  //   13 = top   + W     + jets    (topprc = 3)
+  //   13 = top   + W     + b       (topprc = 4)
+  //   16 = QQbar + gamma + jets    (QQbar = ttbar)
+  //
+  // When tops are present, they are decayed to Wb (both the W and b
+  // are not given), with this W also decaying (decay products given).
+  // The top is marked intermediate, the (intermediate) W is
+  // reconstructed from its decay products, and the decay product mothers
+  // updated. The final-state b is reconstructed from (top - W).
+  //
+  // W/Z resonances are given, as well as their decay products. The
+  // W/Z is marked intermediate, and the decay product mothers updated.
+  //
+  // It is always assumed that decay products are at the end.
+  // For processes 5 and 13, it is also assumed that the decay products
+  // are in the same order as the resonances.
+  // For processes 6, 8 and 16, the possibility of the decay products
+  // being out-of-order is also taken into account.
+  } else if ( ((lprup == 6 || lprup == 8 || lprup == 16) && ihvy1 == 6) ||
+              lprup == 5 || lprup == 13) {
+
+    // Go backwards through the particles looking for W/Z/top
+    int idx = myParticles.size() - 1;
+    for (int i = myParticles.size() - 1; i > -1; i--) {
+
+      // W or Z
+      if (myParticles[i].idPart == 23 ||
+          abs(myParticles[i].idPart) == 24) {
+
+        // Check that decay products and resonance match up
+        int flav;
+        if (myParticles[idx].idPart + myParticles[idx - 1].idPart == 0)
+          flav = 0;
+        else
+          flav = - (myParticles[idx].idPart % 2)
+                 - (myParticles[idx - 1].idPart % 2);
+        flav = (flav > 0) ? 24 : (flav < 0) ? -24 : 23;
+        if (flav != myParticles[i].idPart) {
+          if (infoPtr)
+            infoPtr->errorMsg("Error in LHAupAlpgen::addResonance: "
+                "resonance does not match decay products");
+          return false;
+        }
+
+        // Update status/mothers
+        myParticles[i].statusPart      = 2;
+        myParticles[idx  ].mother1Part = i + 1;
+        myParticles[idx--].mother2Part = 0;
+        myParticles[idx  ].mother1Part = i + 1;
+        myParticles[idx--].mother2Part = 0;
+
+      // Top
+      } else if (abs(myParticles[i].idPart) == 6) {
+
+        // Check that decay products and resonance match up
+        int flav;
+        if (myParticles[idx].idPart + myParticles[idx - 1].idPart == 0)
+          flav = 0;
+        else
+          flav = - (myParticles[idx].idPart % 2)
+                 - (myParticles[idx - 1].idPart % 2);
+        flav = (flav > 0) ? 24 : (flav < 0) ? -24 : 23;
+
+        bool outOfOrder = false, wrongFlavour = false;;
+        if ( abs(flav) != 24 ||
+             (flav ==  24 && myParticles[i].idPart !=  6) ||
+             (flav == -24 && myParticles[i].idPart != -6) ) {
+
+          // Processes 5 and 13, order should always be correct
+          if (lprup == 5 || lprup == 13) {
+            wrongFlavour = true;
+
+          // Processes 6, 8 and 16, can have out of order decay products
+          } else {
+
+            // Go back two decay products and retry
+            idx -= 2;
+            if (myParticles[idx].idPart + myParticles[idx - 1].idPart == 0)
+              flav = 0;
+            else
+              flav = - (myParticles[idx].idPart % 2)
+                     - (myParticles[idx - 1].idPart % 2);
+            flav = (flav > 0) ? 24 : (flav < 0) ? -24 : 23;
+
+            // If still the wrong flavour then error
+            if ( abs(flav) != 24 ||
+                 (flav ==  24 && myParticles[i].idPart !=  6) ||
+                 (flav == -24 && myParticles[i].idPart != -6) )
+              wrongFlavour = true;
+            else outOfOrder = true;
+          }
+
+          // Error if wrong flavour
+          if (wrongFlavour) {
+            if (infoPtr)
+              infoPtr->errorMsg("Error in LHAupAlpgen::addResonance: "
+                  "resonance does not match decay products");
+            return false;
+          }
+        }
+
+        // Mark t/tbar as now intermediate
+        myParticles[i].statusPart = 2;
+
+        // New intermediate W+/W-
+        idT      = flav;
+        statusT  = 2;
+        mother1T = i + 1;
+        mother2T = 0;
+        col1T = col2T = 0;
+        pxT = myParticles[idx].pxPart + myParticles[idx - 1].pxPart;
+        pyT = myParticles[idx].pyPart + myParticles[idx - 1].pyPart;
+        pzT = myParticles[idx].pzPart + myParticles[idx - 1].pzPart;
+        eT  = myParticles[idx].ePart  + myParticles[idx - 1].ePart;
+        mT  = sqrt(eT*eT - pxT*pxT - pyT*pyT - pzT*pzT);
+        myParticles.push_back(LHAParticle(
+            idT, statusT, mother1T, mother2T, col1T, col2T,
+            pxT, pyT, pzT, eT, mT, tauT, spinT));
+
+        // Update the decay product mothers
+        myParticles[idx  ].mother1Part = myParticles.size();
+        myParticles[idx--].mother2Part = 0;
+        myParticles[idx  ].mother1Part = myParticles.size();
+        myParticles[idx--].mother2Part = 0;
+
+        // New final-state b/bbar
+        idT     = (flav == 24) ? 5 : -5;
+        statusT = 1;
+        // Colour from top
+        col1T   = myParticles[i].col1Part;
+        col2T   = myParticles[i].col2Part;
+        // Momentum from (t/tbar - W+/W-)
+        pxT     = myParticles[i].pxPart - myParticles.back().pxPart;
+        pyT     = myParticles[i].pyPart - myParticles.back().pyPart;
+        pzT     = myParticles[i].pzPart - myParticles.back().pzPart;
+        eT      = myParticles[i].ePart  - myParticles.back().ePart;
+        mT      = sqrt(eT*eT - pxT*pxT - pyT*pyT - pzT*pzT);
+        myParticles.push_back(LHAParticle(
+            idT, statusT, mother1T, mother2T, col1T, col2T,
+            pxT, pyT, pzT, eT, mT, tauT, spinT));
+
+        // If decay products were out of order, reset idx to point
+        // at correct decay products
+        if (outOfOrder) idx += 4;
+
+      } // if (abs(myParticles[i].idPart) == 6)
+    } // for (i)
+
+
+  // Processes:
+  //    7 = QQbar + Q'Qbar' + jets (tops are not decayed)
+  //    9 =                   jets
+  //   11 = gamma           + jets
+  //   12 = Higgs           + jets
+  } else if (lprup == 7 || lprup == 9 || lprup == 11 || lprup == 12) {
+    // Nothing to do for these processes
+  }
+
+  // For single top, set incoming b mass if necessary
+  if (lprup == 13) for (int i = 0; i < 2; i++)
+    if (abs(myParticles[i].idPart) == 5) {
+      myParticles[i].mPart = mb;
+      myParticles[i].ePart = sqrt(pow2(myParticles[i].pzPart) + pow2(mb));
+    }
+
+  // Debug output and done.
+#ifdef LHADEBUG
+  printParticles();
+#endif
+  return true;
+}
+
+// ----------------------------------------------------------------------
+
+// Routine to rescale momenta to remove any imbalances. The routine
+// assumes that any imbalances are due to decimal output/rounding
+// effects, and are therefore small.
+//
+// First any px/py imbalances are fixed by adjusting all outgoing
+// particles px/py and also updating their energy so mass is fixed.
+// Because incoming pT is zero, changes should be limited to ~0.001.
+//
+// Second, any pz/e imbalances are fixed by scaling the incoming beams
+// (again, no changes to masses required). Because incoming pz/e is not
+// zero, effects can be slightly larger ~0.002/0.003.
+
+bool LHAupAlpgen::rescaleMomenta() {
+
+  // Total momenta in/out
+  int  nOut = 0;
+  Vec4 pIn, pOut;
+  for (int i = 0; i < int(myParticles.size()); i++) {
+    Vec4 pNow = Vec4(myParticles[i].pxPart, myParticles[i].pyPart,
+                     myParticles[i].pzPart, myParticles[i].ePart);
+    if (i < 2) pIn += pNow;
+    else if (myParticles[i].statusPart == 1) {
+      nOut++;
+      pOut += pNow;
+    }
+  }
+
+  // pT out to match pT in. Split any imbalances over all outgoing
+  // particles, and scale energies also to keep m^2 fixed.
+  if (abs(pOut.pT() - pIn.pT()) > ZEROTHRESHOLD) {
+    // Differences in px/py
+    double pxDiff = (pOut.px() - pIn.px()) / nOut,
+           pyDiff = (pOut.py() - pIn.py()) / nOut;
+
+    // Warn if resulting changes above warning threshold
+    if (pxDiff > PTWARNTHRESHOLD || pyDiff > PTWARNTHRESHOLD) {
+      if (infoPtr) infoPtr->errorMsg("Warning in LHAupAlpgen::setEvent: "
+          "large pT imbalance in incoming event");
+
+      // Debug
+#ifdef LHADEBUGRESCALE
+      printParticles();
+      cout << "pxDiff = " << pxDiff << ", pyDiff = " << pyDiff << endl;
+#endif
+    }
+
+    // Adjust all final-state outgoing
+    pOut.reset();
+    for (int i = 2; i < int(myParticles.size()); i++) {
+      if (myParticles[i].statusPart != 1) continue;
+      myParticles[i].pxPart -= pxDiff;
+      myParticles[i].pyPart -= pyDiff;
+      myParticles[i].ePart   = sqrt(max(0., pow2(myParticles[i].pxPart) +
+          pow2(myParticles[i].pyPart) + pow2(myParticles[i].pzPart) +
+          pow2(myParticles[i].mPart)));
+      pOut += Vec4(myParticles[i].pxPart, myParticles[i].pyPart,
+                   myParticles[i].pzPart, myParticles[i].ePart);
+    }
+  }
+
+  // Differences in E/pZ and scaling factors
+  double de = (pOut.e()  - pIn.e());
+  double dp = (pOut.pz() - pIn.pz());
+  double a  = 1 + (de + dp) / 2. / myParticles[0].ePart;
+  double b  = 1 + (de - dp) / 2. / myParticles[1].ePart;
+
+  // Warn if resulting energy changes above warning threshold.
+  // Change in pz less than or equal to change in energy (incoming b
+  // quark can have mass at this stage for process 13). Note that for
+  // very small incoming momenta, the relative adjustment may be large,
+  // but still small in absolute terms.
+  if (abs(a - 1.) * myParticles[0].ePart > EWARNTHRESHOLD ||
+      abs(b - 1.) * myParticles[1].ePart > EWARNTHRESHOLD) {
+    if (infoPtr) infoPtr->errorMsg("Warning in LHAupAlpgen::setEvent: "
+        "large rescaling factor");
+
+    // Debug output
+#ifdef LHADEBUGRESCALE
+    printParticles();
+    cout << "de = " << de << ", dp = " << dp
+         << ", a = " << a << ", b = " << b << endl
+         << "Absolute energy change for incoming 0 = "
+         << abs(a - 1.) * myParticles[0].ePart << endl
+         << "Absolute energy change for incoming 1 = "
+         << abs(b - 1.) * myParticles[1].ePart << endl;
+#endif
+  }
+  myParticles[0].ePart  *= a;
+  myParticles[0].pzPart *= a;
+  myParticles[1].ePart  *= b;
+  myParticles[1].pzPart *= b;
+
+  // Recalculate resonance four vectors
+  for (int i = 0; i < int(myParticles.size()); i++) {
+    if (myParticles[i].statusPart != 2) continue;
+
+    // Only mothers stored in LHA, so go through all
+    Vec4 resVec;
+    for (int j = 0; j < int(myParticles.size()); j++) {
+      if (myParticles[j].mother1Part - 1 != i) continue;
+      resVec += Vec4(myParticles[j].pxPart, myParticles[j].pyPart,
+                     myParticles[j].pzPart, myParticles[j].ePart);
+    }
+
+    myParticles[i].pxPart = resVec.px();
+    myParticles[i].pyPart = resVec.py();
+    myParticles[i].pzPart = resVec.pz();
+    myParticles[i].ePart  = resVec.e();
+  }
+
+  return true;
+}
+
+//==========================================================================
+
+// AlpgenHooks: provides Alpgen file reading options.
+// Note that it is defined with virtual inheritance, so that it can
+// be combined with other UserHooks classes, see e.g. main32.cc.
+
+class AlpgenHooks : virtual public UserHooks {
+
+public:
+
+  // Constructor and destructor
+  AlpgenHooks(Pythia &pythia);
+  ~AlpgenHooks() { if (LHAagPtr) delete LHAagPtr; }
+
+  // Override initAfterBeams routine from UserHooks
+  bool initAfterBeams();
+
+private:
+
+  // LHAupAlpgen pointer
+  LHAupAlpgen *LHAagPtr;
+};
+
+// ----------------------------------------------------------------------
+
+// Main implementation of AlpgenHooks class. This may be split out to a
+// separate C++ file if desired, but currently included here for ease
+// of use.
+
+// ----------------------------------------------------------------------
+
+// Constructor: provides the 'Alpgen:file' option by directly
+//              changing the Pythia 'Beams' settings
+
+AlpgenHooks::AlpgenHooks(Pythia &pythia) : LHAagPtr(NULL) {
+
+  // If LHAupAlpgen needed, construct and pass to Pythia
+  string agFile = pythia.settings.word("Alpgen:file");
+  if (agFile != "void") {
+    LHAagPtr = new LHAupAlpgen(agFile.c_str(), &pythia.info);
+    pythia.settings.mode("Beams:frameType", 5);
+    pythia.setLHAupPtr(LHAagPtr);
+  }
+}
+
+// ----------------------------------------------------------------------
+
+// Initialisation routine which is called by pythia.init().
+// This happens after the local pointers have been assigned and after
+// Pythia has processed the Beam information (and therefore LHEF header
+// information has been read in), but before any other internal
+// initialisation. Provides the remaining 'Alpgen:*' options.
+
+bool AlpgenHooks::initAfterBeams() {
+
+  // Read in ALPGEN specific configuration variables
+  bool setMasses = settingsPtr->flag("Alpgen:setMasses");
+  bool setNjet   = settingsPtr->flag("Alpgen:setNjet");
+  bool setMLM    = settingsPtr->flag("Alpgen:setMLM");
+
+  // If ALPGEN parameters are present, then parse in AlpgenPar object
+  AlpgenPar par(infoPtr);
+  string parStr = infoPtr->header("AlpgenPar");
+  if (!parStr.empty()) {
+    par.parse(parStr);
+    par.printParams();
+  }
+
+  // Set masses if requested
+  if (setMasses) {
+    if (par.haveParam("mc")) particleDataPtr->m0(4,  par.getParam("mc"));
+    if (par.haveParam("mb")) particleDataPtr->m0(5,  par.getParam("mb"));
+    if (par.haveParam("mt")) particleDataPtr->m0(6,  par.getParam("mt"));
+    if (par.haveParam("mz")) particleDataPtr->m0(23, par.getParam("mz"));
+    if (par.haveParam("mw")) particleDataPtr->m0(24, par.getParam("mw"));
+    if (par.haveParam("mh")) particleDataPtr->m0(25, par.getParam("mh"));
+  }
+
+  // Set MLM:nJets if requested
+  if (setNjet) {
+    if (par.haveParam("njets"))
+      settingsPtr->mode("MLM:nJet", par.getParamAsInt("njets"));
+    else
+      infoPtr->errorMsg("Warning in AlpgenHooks:init: "
+          "no ALPGEN nJet parameter found");
+  }
+
+  // Set MLM merging parameters if requested 
+  if (setMLM) {
+    if (par.haveParam("ptjmin") && par.haveParam("drjmin") &&
+        par.haveParam("etajmax")) {
+      double ptjmin = par.getParam("ptjmin");
+      ptjmin = max(ptjmin + 5., 1.2 * ptjmin);
+      settingsPtr->parm("MLM:eTjetMin",   ptjmin);
+      settingsPtr->parm("MLM:coneRadius", par.getParam("drjmin"));
+      settingsPtr->parm("MLM:etaJetMax",  par.getParam("etajmax"));
+
+    // Warn if setMLM requested, but parameters not present
+    } else {
+      infoPtr->errorMsg("Warning in AlpgenHooks:init: "
+          "no ALPGEN merging parameters found");
+    }
+  }
+
+  // Initialisation complete.
+  return true;
+}
+
+//==========================================================================
+
+#endif // LHAUPALPGEN_H
diff --git a/PYTHIA8/pythia8170/examples/MLMhooks.h b/PYTHIA8/pythia8170/examples/MLMhooks.h
new file mode 100644 (file)
index 0000000..2a778e3
--- /dev/null
@@ -0,0 +1,777 @@
+// MLMhooks.h is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Author: Richard Corke (richard.corke@thep.lu.se)
+// This file provides the MLMhooks class to perform MLM merging.
+// Example usage is shown in main32.cc, and further details
+// can be found in the 'Alpgen and MLM Merging' manual page.
+
+#ifndef MLMHOOKS_H
+#define MLMHOOKS_H
+
+// Includes
+#include "Pythia.h"
+using namespace Pythia8;
+
+//==========================================================================
+
+// Preprocessor settings
+
+// Debug flag to give verbose information at all stages of the merging.
+//#define MLMDEBUG
+// Debug flag to enable some extra checks in the code
+//#define MLMCHECK
+
+//==========================================================================
+
+// Declaration of main MLMhooks class to perform MLM matching.
+// Note that it is defined with virtual inheritance, so that it can
+// be combined with other UserHooks classes, see e.g. main32.cc.
+
+class MLMhooks : virtual public UserHooks {
+
+public:
+
+  // Constructor and destructor
+  MLMhooks() : cellJet(NULL), slowJet(NULL) {}
+  ~MLMhooks() {
+    if (cellJet) delete cellJet;
+    if (slowJet) delete slowJet; 
+  }
+
+  // Initialisation
+  virtual bool initAfterBeams();
+
+  // Process level vetos
+  virtual bool canVetoProcessLevel();
+  virtual bool doVetoProcessLevel(Event &);
+
+  // Parton level vetos (before beam remnants and resonance decays)
+  virtual bool canVetoPartonLevelEarly();
+  virtual bool doVetoPartonLevelEarly(const Event &);
+
+private:
+
+  // Different steps of the MLM matching algorithm
+  void sortIncomingProcess(const Event &);
+  void jetAlgorithmInput(const Event &, int);
+  void runJetAlgorithm();
+  bool matchPartonsToJets(int);
+  int  matchPartonsToJetsLight();
+  int  matchPartonsToJetsHeavy();
+
+  // DeltaR between two 4-vectors (eta and y variants)
+  inline double Vec4eta(const Vec4 &pIn) {
+    return -log(tan(pIn.theta() / 2.));
+  }
+  inline double Vec4y(const Vec4 &pIn) {
+    return 0.5 * log((pIn.e() + pIn.pz()) / (pIn.e() - pIn.pz()));
+  }
+  inline double deltaReta(const Vec4 &p1, const Vec4 &p2) {
+    double dEta = abs(Vec4eta(p1) - Vec4eta(p2));
+    double dPhi = abs(p1.phi() - p2.phi());
+    if (dPhi > M_PI) dPhi = 2. * M_PI - dPhi;
+    return sqrt(dEta*dEta + dPhi*dPhi);
+  }
+  inline double deltaRy(const Vec4 &p1, const Vec4 &p2) {
+    double dy   = abs(Vec4y(p1) - Vec4y(p2));
+    double dPhi = abs(p1.phi() - p2.phi());
+    if (dPhi > M_PI) dPhi = 2. * M_PI - dPhi;
+    return sqrt(dy*dy + dPhi*dPhi);
+  }
+
+  // Function to sort typeIdx vectors into descending eT/pT order.
+  // Uses a selection sort, as number of partons generally small
+  // and so efficiency not a worry.
+  void sortTypeIdx(vector < int > &vecIn) {
+    for (size_t i = 0; i < vecIn.size(); i++) {
+      size_t jMax = i;
+      double vMax = (jetAlgorithm == 1) ?
+                    eventProcess[vecIn[i]].eT() :
+                    eventProcess[vecIn[i]].pT();
+      for (size_t j = i + 1; j < vecIn.size(); j++) {
+        double vNow = (jetAlgorithm == 1) ?
+                      eventProcess[vecIn[j]].eT() :
+                      eventProcess[vecIn[j]].pT();
+        if (vNow > vMax) {
+          vMax = vNow;
+          jMax = j;
+        }
+      }
+      if (jMax != i) swap(vecIn[i], vecIn[jMax]);
+    }
+  }
+
+  // Master switch for merging
+  bool   doMerge;
+
+  // Maximum and current number of jets
+  int    nJetMax, nJet;
+
+  // Jet algorithm parameters
+  int    jetAlgorithm;
+  double eTjetMin, coneRadius, etaJetMax, etaJetMaxAlgo;
+
+  // CellJet specific
+  int    nEta, nPhi;
+  double eTseed, eTthreshold;
+
+  // SlowJet specific
+  int    slowJetPower;
+
+  // Merging procedure parameters
+  int    jetAllow, jetMatch, exclusiveMode;
+  double coneMatchLight, coneRadiusHeavy, coneMatchHeavy;
+  bool   exclusive;
+
+  // Event records to store original incoming process, final-state of the
+  // incoming process and what will be passed to the jet algorithm.
+  // Not completely necessary to store all steps, but makes tracking the
+  // steps of the algorithm a lot easier.
+  Event eventProcessOrig, eventProcess, workEventJet;
+
+  // Internal jet algorithms
+  CellJet *cellJet;
+  SlowJet *slowJet;
+
+  // Sort final-state of incoming process into light/heavy jets and 'other'
+  vector < int > typeIdx[3];
+  set    < int > typeSet[3];
+
+  // Momenta output of jet algorithm (to provide same output regardless of
+  // the selected jet algorithm)
+  vector < Vec4 > jetMomenta;
+
+  // Store the minimum eT/pT of matched light jets
+  double eTpTlightMin;
+
+  // Constants
+  static const double GHOSTENERGY, ZEROTHRESHOLD;
+};
+
+//--------------------------------------------------------------------------
+
+// Main implementation of MLMhooks class. This may be split out to a
+// separate C++ file if desired, but currently included here for ease
+// of use.
+
+// Constants: could be changed here if desired, but normally should not.
+// These are of technical nature, as described for each.
+
+// The energy of ghost particles. For technical reasons, this cannot be
+// set arbitrarily low, see 'Particle::TINY' in 'Event.cc' for details.
+const double MLMhooks::GHOSTENERGY   = 1e-15;
+
+// A zero threshold value for double comparisons.
+const double MLMhooks::ZEROTHRESHOLD = 1e-10;
+
+//--------------------------------------------------------------------------
+
+// Initialisation routine automatically called from Pythia::init().
+// Setup all parts needed for the merging.
+
+bool MLMhooks::initAfterBeams() {
+
+  // Read in parameters
+  doMerge         = settingsPtr->flag("MLM:merge");
+  nJet            = settingsPtr->mode("MLM:nJet");
+  nJetMax         = settingsPtr->mode("MLM:nJetMax");
+  jetAlgorithm    = settingsPtr->mode("MLM:jetAlgorithm");
+  eTjetMin        = settingsPtr->parm("MLM:eTjetMin");
+  coneRadius      = settingsPtr->parm("MLM:coneRadius");
+  etaJetMax       = settingsPtr->parm("MLM:etaJetMax");
+  // Use etaJetMax + coneRadius in input to jet algorithms
+  etaJetMaxAlgo   = etaJetMax + coneRadius;
+  // CellJet specific
+  nEta            = settingsPtr->mode("MLM:nEta");
+  nPhi            = settingsPtr->mode("MLM:nPhi");
+  eTseed          = settingsPtr->parm("MLM:eTseed");
+  eTthreshold     = settingsPtr->parm("MLM:eTthreshold");
+  // SlowJet specific
+  slowJetPower    = settingsPtr->mode("MLM:slowJetPower");
+  // Matching procedure
+  jetAllow        = settingsPtr->mode("MLM:jetAllow");
+  jetMatch        = settingsPtr->mode("MLM:jetMatch");
+  coneMatchLight  = settingsPtr->parm("MLM:coneMatchLight");
+  coneRadiusHeavy = settingsPtr->parm("MLM:coneRadiusHeavy");
+  if (coneRadiusHeavy < 0.) coneRadiusHeavy = coneRadius;
+  coneMatchHeavy  = settingsPtr->parm("MLM:coneMatchHeavy");
+  exclusiveMode   = settingsPtr->mode("MLM:exclusive");
+
+  // If not merging, then done
+  if (!doMerge) return true;
+
+  // Exclusive mode; if set to 2, then set based on nJet/nJetMax
+  if (exclusiveMode == 2) {
+
+    // No nJet or nJetMax, so default to exclusive mode
+    if (nJet < 0 || nJetMax < 0) {
+      infoPtr->errorMsg("Warning in MLMhooks:init: "
+          "missing jet multiplicity information; running in exclusive mode");
+      exclusive = true;
+
+    // Inclusive if nJet == nJetMax, exclusive otherwise
+    } else {
+      exclusive = (nJet == nJetMax) ? false : true;
+    }
+
+  // Otherwise, just set as given
+  } else {
+    exclusive = (exclusiveMode == 0) ? false : true;
+  }
+
+  // Initialise chosen jet algorithm. CellJet.
+  if (jetAlgorithm == 1) {
+
+    // Extra options for CellJet. nSel = 1 means that all final-state
+    // particles are taken and we retain control of what to select.
+    // smear/resolution/upperCut are not used and are set to default values.
+    int    nSel = 2, smear = 0;
+    double resolution = 0.5, upperCut = 2.;
+    cellJet = new CellJet(etaJetMaxAlgo, nEta, nPhi, nSel,
+                          smear, resolution, upperCut, eTthreshold);
+
+  // SlowJet
+  } else if (jetAlgorithm == 2) {
+    slowJet = new SlowJet(slowJetPower, coneRadius, eTjetMin, etaJetMaxAlgo);
+  }
+
+  // Check the jetMatch parameter; option 2 only works with SlowJet
+  if (jetAlgorithm == 1 && jetMatch == 2) {
+    infoPtr->errorMsg("Warning in MLMhooks:init: "
+        "jetMatch = 2 only valid with SlowJet algorithm. "
+        "Reverting to jetMatch = 1.");
+    jetMatch = 1;
+  }
+
+  // Setup local event records
+  eventProcessOrig.init("(eventProcessOrig)", particleDataPtr);
+  eventProcess.init("(eventProcess)", particleDataPtr);
+  workEventJet.init("(workEventJet)", particleDataPtr);
+
+  // Print information
+  string jetStr  = (jetAlgorithm ==  1) ? "CellJet" :
+                   (slowJetPower == -1) ? "anti-kT" :
+                   (slowJetPower ==  0) ? "C/A"     :
+                   (slowJetPower ==  1) ? "kT"      : "unknown";
+  string modeStr = (exclusive)         ? "exclusive" : "inclusive";
+  stringstream nJetStr, nJetMaxStr;
+  if (nJet >= 0)    nJetStr    << nJet;    else nJetStr    << "unknown";
+  if (nJetMax >= 0) nJetMaxStr << nJetMax; else nJetMaxStr << "unknown";
+  cout << endl
+       << " *-------  MLM matching parameters  -------*" << endl
+       << " |  nJet                |  " << setw(14)
+       << nJetStr.str() << "  |" << endl
+       << " |  nJetMax             |  " << setw(14)
+       << nJetMaxStr.str() << "  |" << endl
+       << " |  Jet algorithm       |  " << setw(14)
+       << jetStr << "  |" << endl
+       << " |  eTjetMin            |  " << setw(14)
+       << eTjetMin << "  |" << endl
+       << " |  coneRadius          |  " << setw(14)
+       << coneRadius << "  |" << endl
+       << " |  etaJetMax           |  " << setw(14)
+       << etaJetMax << "  |" << endl
+       << " |  jetAllow            |  " << setw(14)
+       << jetAllow << "  |" << endl
+       << " |  jetMatch            |  " << setw(14)
+       << jetMatch << "  |" << endl
+       << " |  coneMatchLight      |  " << setw(14)
+       << coneMatchLight << "  |" << endl
+       << " |  coneRadiusHeavy     |  " << setw(14)
+       << coneRadiusHeavy << "  |" << endl
+       << " |  coneMatchHeavy      |  " << setw(14)
+       << coneMatchHeavy << "  |" << endl
+       << " |  Mode                |  " << setw(14)
+       << modeStr << "  |" << endl
+       << " *-----------------------------------------*" << endl;
+
+  return true;
+}
+
+//--------------------------------------------------------------------------
+
+// Process level veto. Stores incoming event for later.
+
+bool MLMhooks::canVetoProcessLevel() { return doMerge; }
+
+bool MLMhooks::doVetoProcessLevel(Event& process) { 
+
+  // Copy incoming process
+  eventProcessOrig = process;
+  return false;
+}
+
+//--------------------------------------------------------------------------
+
+// Early parton level veto (before beam remnants and resonance showers)
+
+bool MLMhooks::canVetoPartonLevelEarly() { return doMerge; }
+
+bool MLMhooks::doVetoPartonLevelEarly(const Event& event) {
+
+  // 1) Sort the original incoming process. After this step is performed,
+  //    the following assignments have been made:
+  //      eventProcessOrig - the original incoming process
+  //      eventProcess     - the final-state of the incoming process with
+  //                         resonance decays removed (and resonances
+  //                         themselves now with positive status code)
+  //      typeIdx[0/1/2]   - indices into 'eventProcess' of
+  //                         light jets/heavy jets/other
+  //      typeSet[0/1/2]   - indices into 'event' of
+  //                         light jets/heavy jets/other
+  //      workEvent        - partons from the hardest subsystem
+  //                         + ISR + FSR only
+  sortIncomingProcess(event);
+
+  // Debug
+#ifdef MLMDEBUG
+  // Begin
+  cout << endl << "---------- Begin MLM Debug ----------" << endl;
+
+  // Original incoming process
+  cout << endl << "Original incoming process:";
+  eventProcessOrig.list();
+
+  // Final-state of original incoming process
+  cout << endl << "Final-state incoming process:";
+  eventProcess.list();
+
+  // List categories of sorted particles
+  for (size_t i = 0; i < typeIdx[0].size(); i++) 
+    cout << ((i == 0) ? "Light jets: " : ", ")
+         << setw(3) << typeIdx[0][i];
+  for (size_t i = 0; i < typeIdx[1].size(); i++) 
+    cout << ((i == 0) ? "\nHeavy jets: " : ", ")
+         << setw(3) << typeIdx[1][i];
+  for (size_t i = 0; i < typeIdx[2].size(); i++) 
+    cout << ((i == 0) ? "\nOther:      " : ", ")
+         << setw(3) << typeIdx[2][i];
+
+  // Full event at this stage
+  cout << endl << endl << "Event:";
+  event.list();
+
+  // Work event (partons from hardest subsystem + ISR + FSR)
+  cout << endl << "Work event:";
+  workEvent.list();
+#endif
+
+  // 2) Light/heavy jets: iType = 0 (light jets), 1 (heavy jets)
+  int iTypeEnd = (typeIdx[1].empty()) ? 1 : 2;
+  for (int iType = 0; iType < iTypeEnd; iType++) {
+
+    // 2a) Find particles which will be passed from the jet algorithm.
+    //     Input from 'workEvent' and output in 'workEventJet'.
+    jetAlgorithmInput(event, iType);
+
+    // Debug
+#ifdef MLMDEBUG
+    // Jet algorithm event
+    cout << endl << "Jet algorithm event (iType = " << iType << "):";
+    workEventJet.list();
+#endif
+
+    // 2b) Run jet algorithm on 'workEventJet'.
+    //     Output is stored in jetMomenta.
+    runJetAlgorithm();
+
+    // 2c) Match partons to jets and decide if veto is necessary
+    if (matchPartonsToJets(iType) == true) {
+      // Debug
+#ifdef MLMDEBUG
+      cout << endl << "Event vetoed" << endl
+           << "----------  End MLM Debug  ----------" << endl;
+#endif
+      return true;
+    }
+  }
+
+  // Debug
+#ifdef MLMDEBUG
+  cout << endl << "Event accepted" << endl
+       << "----------  End MLM Debug  ----------" << endl;
+#endif
+
+  // If we reached here, then no veto
+  return false;
+}
+
+//--------------------------------------------------------------------------
+
+// Step (1): sort the incoming particles
+
+void MLMhooks::sortIncomingProcess(const Event &event) {
+
+  // Remove resonance decays from original process and keep only final
+  // state. Resonances will have positive status code after this step.
+  omitResonanceDecays(eventProcessOrig, true);
+  eventProcess = workEvent;
+
+  // Sort original process final state into light/heavy jets and 'other'.
+  // Criteria:
+  //   1 <= ID <= 5 and massless, or ID == 21 --> light jet (typeIdx[0])
+  //   4 <= ID <= 6 and massive               --> heavy jet (typeIdx[1])
+  //   All else                               --> other     (typeIdx[2])
+  // Note that 'typeIdx' stores indices into 'eventProcess' (after resonance
+  // decays are omitted), while 'typeSet' stores indices into the original
+  // process record, 'eventProcessOrig', but these indices are also valid
+  // in 'event'.
+  for (int i = 0; i < 3; i++) {
+    typeIdx[i].clear();
+    typeSet[i].clear();
+  }
+  for (int i = 0; i < eventProcess.size(); i++) {
+    // Ignore nonfinal and default to 'other'
+    if (!eventProcess[i].isFinal()) continue;
+    int idx = 2;
+
+    // Light jets
+    if (eventProcess[i].id() == 21 || (eventProcess[i].idAbs() <= 5 &&
+        abs(eventProcess[i].m()) < ZEROTHRESHOLD))
+      idx = 0;
+
+    // Heavy jets
+    else if (eventProcess[i].idAbs() >= 4 && eventProcess[i].idAbs() <= 6)
+      idx = 1;
+
+    // Store
+    typeIdx[idx].push_back(i);
+    typeSet[idx].insert(eventProcess[i].daughter1());
+  }
+
+  // Extract partons from hardest subsystem + ISR + FSR only into
+  // workEvent. Note no resonance showers or MPIs.
+  subEvent(event);
+}
+
+//--------------------------------------------------------------------------
+
+// Step (2a): pick which particles to pass to the jet algorithm
+
+void MLMhooks::jetAlgorithmInput(const Event &event, int iType) {
+
+  // Take input from 'workEvent' and put output in 'workEventJet'
+  workEventJet = workEvent;
+
+  // Loop over particles and decide what to pass to the jet algorithm
+  for (int i = 0; i < workEventJet.size(); ++i) {
+    if (!workEventJet[i].isFinal()) continue;
+
+    // jetAllow option to disallow certain particle types
+    if (jetAllow == 1) {
+
+      // Original AG+Py6 algorithm explicitly excludes tops,
+      // leptons and photons.
+      int id = workEventJet[i].idAbs();
+      if ((id >= 11 && id <= 16) || id == 6 || id == 22) {
+        workEventJet[i].statusNeg();
+        continue;
+      }
+    }
+
+    // Get the index of this particle in original event
+    int idx = workEventJet[i].daughter1();
+
+    // Start with particle idx, and afterwards track mothers
+    while (true) {
+
+      // Light jets
+      if (iType == 0) {
+
+        // Do not include if originates from heavy jet or 'other'
+        if (typeSet[1].find(idx) != typeSet[1].end() ||
+            typeSet[2].find(idx) != typeSet[2].end()) {
+          workEventJet[i].statusNeg();
+          break;
+        }
+
+        // Made it to start of event record so done
+        if (idx == 0) break;
+        // Otherwise next mother and continue
+        idx = event[idx].mother1();
+
+      // Heavy jets
+      } else if (iType == 1) {
+
+        // Only include if originates from heavy jet
+        if (typeSet[1].find(idx) != typeSet[1].end()) break;
+
+        // Made it to start of event record with no heavy jet mother,
+        // so DO NOT include particle
+        if (idx == 0) {
+          workEventJet[i].statusNeg();
+          break;
+        }
+
+        // Otherwise next mother and continue
+        idx = event[idx].mother1();
+
+      } // if (iType)
+    } // while (true)
+  } // for (i)
+
+  // For jetMatch = 2, insert ghost particles corresponding to
+  // each hard parton in the original process
+  if (jetMatch == 2) {
+    for (int i = 0; i < int(typeIdx[iType].size()); i++) {
+      // Get y/phi of the parton
+      Vec4   pIn = eventProcess[typeIdx[iType][i]].p();
+      double y   = Vec4y(pIn);
+      double phi = pIn.phi();
+
+      // Create a ghost particle and add to the workEventJet
+      double e   = GHOSTENERGY;
+      double e2y = exp(2. * y);
+      double pz  = e * (e2y - 1.) / (e2y + 1.);
+      double pt  = sqrt(e*e - pz*pz);
+      double px  = pt * cos(phi);
+      double py  = pt * sin(phi);
+      workEventJet.append(Particle(21, 99, 0, 0, 0, 0, 0, 0,
+                                px, py, pz, e, 0., 0, 9.));
+
+      // Extra check on reconstructed y/phi values. If many warnings
+      // of this type, GHOSTENERGY may be set too low.
+#ifdef MLMCHECK
+      int lastIdx = workEventJet.size() - 1;
+      if (abs(y   - workEventJet[lastIdx].y())   > ZEROTHRESHOLD ||
+          abs(phi - workEventJet[lastIdx].phi()) > ZEROTHRESHOLD)
+        infoPtr->errorMsg("Warning in MLMhooks:jetAlgorithmInput: "
+            "ghost particle y/phi mismatch");
+#endif
+
+    } // for (i)
+  } // if (jetMatch == 2)
+}
+
+//--------------------------------------------------------------------------
+
+// Step (2b): run jet algorithm and provide common output
+
+void MLMhooks::runJetAlgorithm() {
+
+  // Run the jet clustering algorithm
+  if (jetAlgorithm == 1)
+    cellJet->analyze(workEventJet, eTjetMin, coneRadius, eTseed);
+  else
+    slowJet->analyze(workEventJet);
+
+  // Extract four-momenta of jets with |eta| < etaJetMax and
+  // put into jetMomenta. Note that this is done backwards as
+  // jets are removed with SlowJet.
+  jetMomenta.clear();
+  int iJet = (jetAlgorithm == 1) ? cellJet->size() - 1:
+                                   slowJet->sizeJet() - 1;
+  for (int i = iJet; i > -1; i--) {
+    Vec4 jetMom = (jetAlgorithm == 1) ? cellJet->pMassive(i) :
+                                        slowJet->p(i);
+    double eta = Vec4eta(jetMom);
+
+    if (abs(eta) > etaJetMax) {
+      if (jetAlgorithm == 2) slowJet->removeJet(i);
+      continue;
+    }
+    jetMomenta.push_back(jetMom);
+  }
+
+  // Reverse jetMomenta to restore eT/pT ordering
+  reverse(jetMomenta.begin(), jetMomenta.end());
+}
+
+//--------------------------------------------------------------------------
+
+// Step (2c): veto decision (returning true vetoes the event)
+
+bool MLMhooks::matchPartonsToJets(int iType) {
+
+  // Use two different routines for light/heavy jets as
+  // different veto conditions and for clarity
+  if (iType == 0) return (matchPartonsToJetsLight() > 0);
+  else            return (matchPartonsToJetsHeavy() > 0);
+}
+
+//--------------------------------------------------------------------------
+
+// Step(2c): light jets
+// Return codes are given indicating the reason for a veto.
+// Although not currently used, they are a useful debugging tool:
+//   0 = no veto
+//   1 = veto as number of jets less than number of partons
+//   2 = veto as exclusive mode and number of jets greater than
+//       number of partons
+//   3 = veto as inclusive mode and there would be an extra jet
+//       that is harder than any matched soft jet
+//   4 = veto as there is a parton which does not match a jet
+
+int MLMhooks::matchPartonsToJetsLight() {
+
+  // Always veto if number of jets is less than original number of jets
+  if (jetMomenta.size() < typeIdx[0].size()) return 1;
+  // Veto if in exclusive mode and number of jets bigger than original
+  if (exclusive && jetMomenta.size() > typeIdx[0].size()) return 2;
+
+  // Sort partons by eT/pT
+  sortTypeIdx(typeIdx[0]);
+
+  // Number of hard partons
+  int nParton = typeIdx[0].size();
+
+  // Keep track of which jets have been assigned a hard parton
+  vector < bool > jetAssigned;
+  jetAssigned.assign(jetMomenta.size(), false);
+
+  // Jet matching procedure: (1) deltaR between partons and jets
+  if (jetMatch == 1) {
+
+    // Loop over light hard partons and get 4-momentum
+    for (int i = 0; i < nParton; i++) {
+      Vec4 p1 = eventProcess[typeIdx[0][i]].p();
+
+      // Track which jet has the minimal dR measure with this parton
+      int    jMin  = -1;
+      double dRmin = 0.;
+
+      // Loop over all jets (skipping those already assigned).
+      for (int j = 0; j < int(jetMomenta.size()); j++) {
+        if (jetAssigned[j]) continue;
+
+        // DeltaR between parton/jet and store if minimum
+        double dR = (jetAlgorithm == 1) ?
+            deltaReta(p1, jetMomenta[j]) : deltaRy(p1, jetMomenta[j]);
+        if (jMin < 0 || dR < dRmin) {
+          dRmin = dR;
+          jMin  = j;
+        }
+      } // for (j)
+
+      // Check for jet-parton match
+      if (jMin >= 0 && dRmin < coneRadius * coneMatchLight) {
+
+        // If the matched jet is not one of the nParton hardest jets,
+        // the extra left over jet would be harder than some of the
+        // matched jets. This is disallowed, so veto.
+        if (jMin >= nParton) return 3;
+
+        // Mark jet as assigned.
+        jetAssigned[jMin] = true;
+
+      // If no match, then event will be vetoed in all cases
+      } else return 4;
+
+    } // for (i)
+
+  // Jet matching procedure: (2) ghost particles in SlowJet
+  } else {
+
+    // Loop over added 'ghost' particles and find if assigned to a jet
+    for (int i = workEventJet.size() - nParton;
+        i < workEventJet.size(); i++) {
+      int jMin = slowJet->jetAssignment(i);
+
+      // Veto if:
+      //  1) not one of nParton hardest jets
+      //  2) not assigned to a jet
+      //  3) jet has already been assigned
+      if (jMin >= nParton)               return 3;
+      if (jMin < 0 || jetAssigned[jMin]) return 4;
+
+      // Mark jet as assigned
+      jetAssigned[jMin] = true;
+
+    } // for (i)
+  } // if (jetMatch)
+
+  // Minimal eT/pT (CellJet/SlowJet) of matched light jets. Needed
+  // later for heavy jet vetos in inclusive mode.
+  if (nParton > 0)
+    eTpTlightMin = (jetAlgorithm == 1) ? jetMomenta[nParton - 1].eT()
+                                       : jetMomenta[nParton - 1].pT();
+  else
+    eTpTlightMin = -1.;
+
+  // No veto
+  return 0;
+}
+
+//--------------------------------------------------------------------------
+
+// Step(2c): heavy jets
+// Return codes are given indicating the reason for a veto.
+// Although not currently used, they are a useful debugging tool:
+//   0 = no veto as there are no extra jets present
+//   1 = veto as in exclusive mode and extra jets present
+//   2 = veto as in inclusive mode and extra jets were harder
+//       than any matched light jet
+
+int MLMhooks::matchPartonsToJetsHeavy() {
+
+  // If there are no extra jets, then accept
+  if (jetMomenta.empty()) return 0;
+
+  // Number of hard partons
+  int nParton = typeIdx[1].size();
+
+  // Remove jets that are close to heavy quarks
+  set < int > removeJets;
+
+  // Jet matching procedure: (1) deltaR between partons and jets
+  if (jetMatch == 1) {
+
+    // Loop over heavy hard partons and get 4-momentum
+    for (int i = 0; i < nParton; i++) {
+      Vec4 p1 = eventProcess[typeIdx[1][i]].p();
+
+      // Loop over all jets, find dR and mark for removal if match
+      for (int j = 0; j < int(jetMomenta.size()); j++) {
+        double dR = (jetAlgorithm == 1) ?
+            deltaReta(p1, jetMomenta[j]) : deltaRy(p1, jetMomenta[j]);
+        if (dR < coneRadiusHeavy * coneMatchHeavy)
+          removeJets.insert(j);
+
+      } // for (j)
+    } // for (i)
+
+  // Jet matching procedure: (2) ghost particles in SlowJet
+  } else {
+
+    // Loop over added 'ghost' particles and if assigned to a jet
+    // then mark this jet for removal
+    for (int i = workEventJet.size() - nParton;
+        i < workEventJet.size(); i++) {
+      int jMin = slowJet->jetAssignment(i);
+      if (jMin >= 0) removeJets.insert(jMin);
+    }
+      
+  }
+
+  // Remove jets (backwards order to not disturb indices)
+  for (set < int >::reverse_iterator it  = removeJets.rbegin();
+                                     it != removeJets.rend(); it++)
+    jetMomenta.erase(jetMomenta.begin() + *it);
+
+  // Handle case if there are still extra jets
+  if (!jetMomenta.empty()) {
+
+    // Exclusive mode, so immediate veto
+    if (exclusive) return 1;
+
+    // Inclusive mode; extra jets must be softer than any matched light jet
+    else if (eTpTlightMin >= 0.)
+      for (size_t j = 0; j < jetMomenta.size(); j++) {
+        // CellJet uses eT, SlowJet uses pT
+        if ( (jetAlgorithm == 1 && jetMomenta[j].eT() > eTpTlightMin) ||
+             (jetAlgorithm == 2 && jetMomenta[j].pT() > eTpTlightMin) )
+          return 2;
+      }
+
+  } // if (!jetMomenta.empty())
+
+  // No extra jets were present so no veto
+  return 0;
+}
+
+//==========================================================================
+
+#endif // MLMHOOKS_H
diff --git a/PYTHIA8/pythia8170/examples/Makefile b/PYTHIA8/pythia8170/examples/Makefile
new file mode 100644 (file)
index 0000000..6c39cc3
--- /dev/null
@@ -0,0 +1,150 @@
+#
+# Examples Makefile.
+#
+#                  M. Kirsanov 07.04.2006
+#                     Modified 18.11.2006
+#                     26.03.2008 CLHEP dependency removed
+
+SHELL = /bin/sh
+
+-include config.mk
+ifeq (x$(PYTHIA8LOCATION),x)
+ PYTHIA8LOCATION=..
+endif
+-include $(PYTHIA8LOCATION)/config.mk
+
+# Location of directories.
+TOPDIR=$(shell \pwd)
+INCDIR=include
+SRCDIR=src
+LIBDIR=lib
+LIBDIRARCH=lib/archive
+BINDIR=bin
+
+# Libraries to include if GZIP support is enabled
+ifeq (x$(ENABLEGZIP),xyes)
+LIBGZIP=-L$(BOOSTLIBLOCATION) -lboost_iostreams -L$(ZLIBLOCATION) -lz
+endif
+
+# There is no default behaviour, so remind user.
+all:
+       @echo "Usage: for NN = example number: make mainNN"
+
+# Create an executable for one of the normal test programs
+main00  main01 main02 main03 main04 main05 main06 main07 main08 main09 main10 \
+       main11 main12 main13 main14 main15 main16 main17 main18 main19 main20 \
+       main21 main22 main23 main24 main25 main26 main27 main28 main29 main30 \
+       main31 main32 main33 main34 main35 main36 main37 main38 main39 main40: \
+       $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a
+       @mkdir -p $(BINDIR)
+       $(CXX) $(CXXFLAGS) -I$(PYTHIA8LOCATION)/$(INCDIR) $@.cc -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 -llhapdfdummy $(LIBGZIP)
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+
+# Create an executable linked to HepMC (if all goes well).
+# Owing to excessive warning output -Wshadow is not used for HepMC.
+ifneq (x$(HEPMCLOCATION),x)
+  main41 main42: \
+       $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libhepmcinterface.a
+       @mkdir -p $(BINDIR)
+       $(CXX) $(CXXFLAGS) -Wno-shadow -I$(PYTHIA8LOCATION)/$(INCDIR) -I$(HEPMCLOCATION)/include \
+       $@.cc -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 -llhapdfdummy $(LIBGZIP) \
+       -lhepmcinterface \
+       -L$(HEPMCLOCATION)/lib -lHepMC
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+else
+  main41 main42:
+       @echo ERROR, this target needs HepMC, variable HEPMCLOCATION
+endif
+
+# Create an executable that links to LHAPDF
+main51 main52 main53: $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a
+       @mkdir -p $(BINDIR)
+       $(CXX) $(CXXFLAGS) -I$(PYTHIA8LOCATION)/$(INCDIR) $@.cc -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 $(LIBGZIP) \
+       -L$(LHAPDFLOCATION) $(LHAPDFLIBNAME) \
+       $(FLIBS)
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+
+# Create an executable that links to LHAPDF and HepMC
+main61 main62: \
+       $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libhepmcinterface.a
+       @mkdir -p $(BINDIR)
+       $(CXX) $(CXXFLAGS) -Wno-shadow -I$(PYTHIA8LOCATION)/$(INCDIR) -I$(HEPMCLOCATION)/include \
+       $@.cc -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 -lhepmcinterface $(LIBGZIP) \
+       -L$(LHAPDFLOCATION) $(LHAPDFLIBNAME) \
+       -L$(HEPMCLOCATION)/lib -lHepMC \
+       $(FLIBS)
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+
+# Create an executable that links to Fastjet
+# Owing to excessive warning output -Wshadow is not used for Fastjet.
+# (Fixed as of Fastjet 3.0.1, so will be modified eventually.)
+ifneq (x$(FASTJETLOCATION),x)
+  main71 main72: $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a
+       @mkdir -p $(BINDIR)
+    # Note: $(CXXFLAGS) is after Fastjet flags as Fastjet includes
+    #       optimisation/debug flags which may be unwanted (e.g. -g -O2)
+       $(CXX) -I$(PYTHIA8LOCATION)/$(INCDIR) $@.cc \
+       `$(FASTJETLOCATION)/bin/fastjet-config --cxxflags --plugins` \
+       $(CXXFLAGS) -Wno-shadow \
+       -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 -llhapdfdummy $(LIBGZIP) \
+       -L$(FASTJETLOCATION)/lib \
+       `$(FASTJETLOCATION)/bin/fastjet-config --libs --plugins`
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+       @rm -f $@.o
+else
+  main71 main72:
+       @echo ERROR, this target needs Fastjet, variable FASTJETLOCATION
+endif
+
+# Create an executable that links to Fastjet, HepMC and LHApdf
+# Owing to excessive warning output -Wshadow is not used for Fastjet.
+# (Fixed as of Fastjet 3.0.1, so will be modified eventually.)
+ifneq (x$(FASTJETLOCATION),x)
+  main81 main82 main83 main84: \
+       $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a  $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libhepmcinterface.a
+       @mkdir -p $(BINDIR)
+    # Note: $(CXXFLAGS) is after Fastjet flags as Fastjet includes
+    #       optimisation/debug flags which may be unwanted (e.g. -g -O2)
+       $(CXX) -I$(PYTHIA8LOCATION)/$(INCDIR) $@.cc \
+       `$(FASTJETLOCATION)/bin/fastjet-config --cxxflags --plugins` \
+       $(CXXFLAGS) -Wno-shadow \
+       -I$(PYTHIA8LOCATION)/$(INCDIR) -I$(HEPMCLOCATION)/include \
+       -o $(BINDIR)/$@.exe \
+       -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 \
+       -L$(LHAPDFLOCATION) $(LHAPDFLIBNAME) \
+       -lhepmcinterface \
+       -L$(HEPMCLOCATION)/lib -lHepMC \
+       -L$(FASTJETLOCATION)/lib \
+       -L$(LHAPDFLOCATION)/lib \
+       `$(FASTJETLOCATION)/bin/fastjet-config --libs --plugins`
+       @ln -fs $(BINDIR)/$@.exe $@.exe
+       @rm -f $@.o
+else
+  main81 main82 main83 main84:
+       @echo ERROR, this target needs Fastjet, variable FASTJETLOCATION
+endif
+
+# Create an executable that links to Pythia6. This part is obsolete and 
+# only retained, in a watered-down version, for debug purposes.
+# Library created with "gfortran -c pythia64xx.f" (xx = current subversion),
+# followed by "ar cru libpythia6.a pythia64xx.o" (on Linux).
+# You would need to uncomment below and correct pythia6 library path.
+#main91: $(PYTHIA8LOCATION)/$(LIBDIRARCH)/libpythia8.a
+#      @mkdir -p $(BINDIR)
+#      $(CXX) $(CXXFLAGS) -I$(PYTHIA8LOCATION)/$(INCDIR) $@.cc -o $(BINDIR)/$@.exe \
+#      -L$(PYTHIA8LOCATION)/$(LIBDIRARCH) -lpythia8 -llhapdfdummy $(LIBGZIP) \
+#      -L/directoryoflibpythia6.a -lpythia6 \
+#      $(FLIBS)
+#      @ln -fs $(BINDIR)/$@.exe $@.exe
+
+# Clean up: remove executables and outdated files.
+.PHONY: clean
+clean:
+       rm -rf $(BINDIR)
+       rm -rf *.exe
+       rm -f *~; rm -f \#*; rm -f core*
diff --git a/PYTHIA8/pythia8170/examples/README b/PYTHIA8/pythia8170/examples/README
new file mode 100644 (file)
index 0000000..f76637e
--- /dev/null
@@ -0,0 +1,94 @@
+----------------------------------------------------------------------
+
+   BASIC INSTRUCTIONS FOR RUNNING TEST PROGRAMS
+
+1) You are supposed to have already compiled PYTHIA 8, as described in 
+   the README file of the mother directory. For the moment we assume
+   that you will NOT use the HepMC, LHAPDF, or FastJet libraries.
+
+2) You are now ready to test run the first thirty of the mainNN examples,
+   see the manual page "Sample main program" for details.
+   Type "gmake mainNN" to build an executable "mainNN.exe". 
+   Type "./mainNN.exe > output" to run this executable. 
+   Then study the output file. The existing files outNN are examples of 
+   possible outputs from several runs, so that you can compare.
+
+3) If you want to run your own programs from this directory you can edit
+   the "Makefile", adding the name of your main program to the already
+   existing ones. Note that different cases exist, depending on which 
+   external libraries are to be linked. There is no main00, but this 
+   name is defined in the Makefile, so it can be used for simple first 
+   tests.
+
+4) With ./runmains all the 27 first mainXX program will be run,
+   plus main31, to get a thorough test of the installation. 
+   The runmains file can easily be edited to run the others as well,
+   but then you should first link to the appropriate external libraries.
+   The outref subdirectory contains the output of such a run, if you
+   want to compare with what you obtain.
+
+5) Type "gmake clean" to clean up the examples directory (but not the
+   output files).
+
+----------------------------------------------------------------------
+
+   ADVANCED INSTRUCTIONS FOR RUNNING TEST PROGRAMS
+
+1) If you want to be able to run examples linked to HepMC you should 
+   already have set that up with the "./configure" command in the mother 
+   directory. If not, you can go back and do it now. This will create 
+   files "config.csh" and "config.sh" in the current directory.
+
+2) If you are going to run examples linked with LHAPDF and/or FastJet, 
+   or if you want to move (all or parts of) the current examples 
+   subdirectory to a location separate from the rest of the library, 
+   you should as a first step run the script "configure" in the current 
+   directory. You can use command-line arguments to set up the desired 
+   library links. 
+
+   The possible options are:
+     --help : prints a brief summary of the options described here.
+     --enable-debug : turns on debugging flags and turns off optimization
+     --enable-shared : use shared library (not yet implemented; default no)
+     --lcgplatform=name : LCG platform name (can be part of path to 
+         external librtaries; default is x86_64-slc5-gcc43-opt)
+     --with-pythia8=p8path : path to the pythia81xx installation directory, 
+         where the programs in this examples directory can find libraries,
+         includes and parameters (default is ..)
+     --with-lhapdf=lhapdfpath : the path to your local copy of the LHAPDF
+         library (must be version 5.3 or higher)
+     --with-lhapdfversion=v : a simpler alternative to the above, valid 
+         if you are using the CERN AFS MCGenerators area; then you do not 
+         need to specify the full path but only the version, e.g. =5.3.0 
+         (must be version 5.3 or higher) 
+     --with-lhapdflibname=n : lhapdf library name line (default is -lLHAPDF)
+     --with-lhapdfsets=path : path to the LHAPDF data files 
+         (default is lhapdfpath/../PDFsets, CERN AFS default is 
+         lhapdfpath/../../../share/PDFsets)
+     --with-fastjet=path : path to FastJet (default = /usr/local)
+     --with-fastjetversion=v : FastJet version 
+         (simplified alternative when using CERN AFS external, e.g. =2.3.3)
+
+   When "configure" is run it will create or append to the config.csh 
+   and config.sh files.
+
+3) Before running the examples using external libraries for the first 
+   time, type "source config.csh" if you use the csh or tcsh shell, or 
+   "source config.sh" otherwise. (Use "echo $SHELL" if uncertain.)
+   This will set or append the environment variables LD_LIBRARY_PATH,
+   needed to find the HepMC libraries. (Eventually also LHAPDF and FastJet
+   libraries, if shared ones are used. Default, if taken from CERN AFS 
+   MCGenerators, is archive.) It will also set the variable LHAPATH, 
+   needed to find the LHAPDF data files.
+
+4) If you want to change to other LHAPDF or FastJet or versions, you 
+   have to rerun the script "configure" and again "source" one of the 
+   config.* files. In case of using shared libraries (these will  be taken 
+   if both shared and archive ones are on the same path) pay attention to 
+   the variable LD_LIBRARY_PATH: subsequent commands "source" will add new 
+   items to it, not substitute the old ones. As a result, the wrong 
+   version can still be loaded at runtime, which can cause relocation 
+   errors. A simple solution is to repeat the "configure" and "source" 
+   steps in a new window, i.e. in a new clean copy of the shell.
+
+----------------------------------------------------------------------
diff --git a/PYTHIA8/pythia8170/examples/cmssm.spc b/PYTHIA8/pythia8170/examples/cmssm.spc
new file mode 100644 (file)
index 0000000..2d742cd
--- /dev/null
@@ -0,0 +1,151 @@
+# SOFTSUSY3.3.0 SLHA compliant output
+# B.C. Allanach, Comput. Phys. Commun. 143 (2002) 305-331, hep-ph/0104145
+# CMSSM 10.1.1 input - see arXiv:1109.3859
+Block SPINFO          # Program information
+     1    SOFTSUSY    # spectrum calculator
+     2    3.3.0       # version number
+Block MODSEL  # Select model
+     1    1   # sugra
+Block SMINPUTS             # Standard Model inputs
+     1    1.27934000e+02   # alpha_em^(-1)(MZ) SM MSbar
+     2    1.16637000e-05   # G_Fermi
+     3    1.17200000e-01   # alpha_s(MZ)MSbar
+     4    9.11876000e+01   # MZ(pole)
+     5    4.25000000e+00   # mb(mb)
+     6    1.74300000e+02   # Mtop(pole)
+     7    1.77700000e+00   # Mtau(pole)
+Block MINPAR               # SUSY breaking input parameters
+     1    1.25000000e+02   # m0
+     2    5.00000000e+02   # m12
+     3    1.00000000e+01   # tanb
+     4    1.00000000e+00   # sign(mu)
+     5    0.00000000e+00   # A0
+# Low energy data in SOFTSUSY: MIXING=0 TOLERANCE=1.00000000e-03
+# mgut=1.87825797e+16 GeV
+Block MASS                      # Mass spectrum
+# PDG code     mass             particle
+        24     8.04613815e+01   # MW
+        25     1.15412339e+02   # h0
+        35     7.21892898e+02   # H0
+        36     7.21606682e+02   # A0
+        37     7.26310615e+02   # H+
+   1000021     1.14687814e+03   # ~g
+   1000022     2.04168238e+02   # ~neutralino(1)
+   1000023     3.86197315e+02   # ~neutralino(2)
+   1000024     3.86332261e+02   # ~chargino(1)
+   1000025    -6.39638883e+02   # ~neutralino(3)
+   1000035     6.53032956e+02   # ~neutralino(4)
+   1000037     6.52679913e+02   # ~chargino(2)
+   1000001     1.05561088e+03   # ~d_L
+   1000002     1.05278695e+03   # ~u_L
+   1000003     1.05560831e+03   # ~s_L
+   1000004     1.05278437e+03   # ~c_L
+   1000005     9.65462335e+02   # ~b_1
+   1000006     8.03540912e+02   # ~t_1
+   1000011     3.61778036e+02   # ~e_L
+   1000012     3.52902884e+02   # ~nue_L
+   1000013     3.61861990e+02   # ~mu_L
+   1000014     3.52899536e+02   # ~numu_L
+   1000015     2.22692429e+02   # ~stau_1
+   1000016     3.51730554e+02   # ~nu_tau_L
+   2000001     1.01102319e+03   # ~d_R
+   2000002     1.01434248e+03   # ~u_R
+   2000003     1.01102050e+03   # ~s_R
+   2000004     1.01433974e+03   # ~c_R
+   2000005     1.00775879e+03   # ~b_2
+   2000006     1.01102814e+03   # ~t_2
+   2000011     2.29874717e+02   # ~e_R
+   2000013     2.29864278e+02   # ~mu_R
+   2000015     3.62940076e+02   # ~stau_2
+Block alpha                     # Effective Higgs mixing parameter
+          -1.06797662e-01       # alpha
+Block nmix                  # neutralino mixing matrix
+  1  1     9.95886986e-01   # N_{1,1}
+  1  2    -1.72694202e-02   # N_{1,2}
+  1  3     8.22024839e-02   # N_{1,3}
+  1  4    -3.39651202e-02   # N_{1,4}
+  2  1     3.74375188e-02   # N_{2,1}
+  2  2     9.71264892e-01   # N_{2,2}
+  2  3    -1.95766260e-01   # N_{2,3}
+  2  4     1.30071184e-01   # N_{2,4}
+  3  1    -3.30727556e-02   # N_{3,1}
+  3  2     4.82085025e-02   # N_{3,2}
+  3  3     7.03472841e-01   # N_{3,3}
+  3  4     7.08313557e-01   # N_{3,4}
+  4  1    -7.55892561e-02   # N_{4,1}
+  4  2     2.32426798e-01   # N_{4,2}
+  4  3     6.78265645e-01   # N_{4,3}
+  4  4    -6.92978905e-01   # N_{4,4}
+Block Umix                  # chargino U mixing matrix 
+  1  1     9.60950435e-01   # U_{1,1}
+  1  2    -2.76720547e-01   # U_{1,2}
+  2  1     2.76720547e-01   # U_{2,1}
+  2  2     9.60950435e-01   # U_{2,2}
+Block Vmix                  # chargino V mixing matrix 
+  1  1     9.82582136e-01   # V_{1,1}
+  1  2    -1.85828808e-01   # V_{1,2}
+  2  1     1.85828808e-01   # V_{2,1}
+  2  2     9.82582136e-01   # V_{2,2}
+Block stopmix               # stop mixing matrix
+  1  1     4.24985787e-01   # F_{11}
+  1  2     9.05200023e-01   # F_{12}
+  2  1     9.05200023e-01   # F_{21}
+  2  2    -4.24985787e-01   # F_{22}
+Block sbotmix               # sbottom mixing matrix
+  1  1     9.75941340e-01   # F_{11}
+  1  2     2.18033254e-01   # F_{12}
+  2  1    -2.18033254e-01   # F_{21}
+  2  2     9.75941340e-01   # F_{22}
+Block staumix               # stau mixing matrix
+  1  1     1.42739201e-01   # F_{11}
+  1  2     9.89760335e-01   # F_{12}
+  2  1     9.89760335e-01   # F_{21}
+  2  2    -1.42739201e-01   # F_{22}
+Block gauge Q= 8.73811408e+02  # SM gauge couplings
+     1     3.62408332e-01   # g'(Q)MSSM DRbar
+     2     6.43000889e-01   # g(Q)MSSM DRbar
+     3     1.06090510e+00   # g3(Q)MSSM DRbar
+Block yu Q= 8.73811408e+02  
+  3  3     8.67028746e-01   # Yt(Q)MSSM DRbar
+Block yd Q= 8.73811408e+02  
+  3  3     1.35275115e-01   # Yb(Q)MSSM DRbar
+Block ye Q= 8.73811408e+02  
+  3  3     1.00502013e-01   # Ytau(Q)MSSM DRbar
+Block hmix Q= 8.73811408e+02 # Higgs mixing parameters
+     1     6.34225757e+02    # mu(Q)MSSM DRbar
+     2     9.66949856e+00    # tan beta(Q)MSSM DRbar
+     3     2.44043659e+02    # higgs vev(Q)MSSM DRbar
+     4     5.40020729e+05    # mA^2(Q)MSSM DRbar
+Block msoft Q= 8.73811408e+02  # MSSM DRbar SUSY breaking parameters
+     1     2.09217931e+02      # M_1(Q)
+     2     3.88513213e+02      # M_2(Q)
+     3     1.11375823e+03      # M_3(Q)
+    21     1.09175993e+05      # mH1^2(Q)
+    22    -3.89577899e+05      # mH2^2(Q)
+    31     3.54297503e+02      # meL(Q)
+    32     3.54294169e+02      # mmuL(Q)
+    33     3.53288859e+02      # mtauL(Q)
+    34     2.22024882e+02      # meR(Q)
+    35     2.22014061e+02      # mmuR(Q)
+    36     2.18730815e+02      # mtauR(Q)
+    41     1.01868349e+03      # mqL1(Q)
+    42     1.01868086e+03      # mqL2(Q)
+    43     9.38174894e+02      # mqL3(Q)
+    44     9.80660335e+02      # muR(Q)
+    45     9.80657548e+02      # mcR(Q)
+    46     8.05547302e+02      # mtR(Q)
+    47     9.76062679e+02      # mdR(Q)
+    48     9.76059936e+02      # msR(Q)
+    49     9.71058708e+02      # mbR(Q)
+Block au Q= 8.73811408e+02  
+  1  1    -1.13744947e+03      # Au(Q)MSSM DRbar
+  2  2    -1.13744435e+03      # Ac(Q)MSSM DRbar
+  3  3    -8.73322525e+02      # At(Q)MSSM DRbar
+Block ad Q= 8.73811408e+02  
+  1  1    -1.39629474e+03      # Ad(Q)MSSM DRbar
+  2  2    -1.39628999e+03      # As(Q)MSSM DRbar
+  3  3    -1.30365153e+03      # Ab(Q)MSSM DRbar
+Block ae Q= 8.73811408e+02  
+  1  1    -2.99482647e+02      # Ae(Q)MSSM DRbar
+  2  2    -2.99477266e+02      # Amu(Q)MSSM DRbar
+  3  3    -2.97855048e+02      # Atau(Q)MSSM DRbar
diff --git a/PYTHIA8/pythia8170/examples/configure b/PYTHIA8/pythia8170/examples/configure
new file mode 100755 (executable)
index 0000000..7797eb4
--- /dev/null
@@ -0,0 +1,436 @@
+#!/bin/sh
+#
+# Configuration script, to be run before making examples
+#
+# Author: M. Kirsanov
+
+#
+# User-changeable part -------------------------------
+#
+
+#LCG platform. Can be needed if external libraries are specified
+if [ x$MYLCGPLATFORM = x ]; then
+  export MYLCGPLATFORM=x86_64-slc5-gcc43-opt
+fi
+
+# Defaults
+export COMPMODE=OPT
+export PYTHIA8LOCATION=..
+
+# check arguments
+
+for arg in $* ; do
+  if [ "x$arg" = "x--enable-debug" ] ; then
+    COMPMODE=DBG
+  elif [ "x$arg" = "x--enable-shared" ] ; then
+    SHAREDLIBS=yes
+  elif [ "x$arg" = "x--help" ] ; then
+    echo "Usage: ./configure [options] , where options are:"
+    echo "--help                   : prints this help"
+    echo "--enable-debug           : turns on debugging flags and turns off optimization"
+    echo "--enable-shared          : use shared library (not yet implemented) (default no)"
+    echo "--lcgplatform=name       : LCG platform name, default is slc4_ia32_gcc34"
+    echo "--with-pythia8=p8path    : path to pythia8 installation dir to find libs, includes and pars (default is ..)"
+    echo "--with-lhapdf=lhapdfpath : path to LHAPDF libraries dir (LHAPDF must be version 5.3 or higher)"
+    echo "--with-lhapdfversion=v   : LHAPDF version (simplified alternative when using CERN AFS MCGenerators, e.g. =5.5.1.a)"
+    echo "--with-lhapdflibname=n   : lhapdf library name line (default is -lLHAPDF)"
+    echo "--with-lhapdfsets=path   : path to LHAPDF data (default is lhapdfpath/../PDFsets, CERN AFS default is lhapdfpath/../../../share/PDFsets)"
+    echo "--with-fastjet=path      : path to fastjet (default = /usr/local)"
+    echo "--with-fastjetversion=v  : fastjet version (simplified alternative when using CERN AFS external, e.g. =2.3.3)"
+    exit
+  elif [ x`echo x${arg} | grep "="` != x ] ; then
+    option=`echo ${arg} | awk -F = '{print $1}'`
+    value=`echo ${arg} | awk -F = '{print $2}'`
+    if [ "x${option}" = "x--lcgplatform" ] ; then
+      MYLCGPLATFORM=${value}
+    elif [ "x${option}" = "x--with-pythia8" ] ; then
+      PYTHIA8LOCATION=${value}
+    elif [ "x${option}" = "x--with-lhapdfversion" ] ; then
+      LHAPDFVERSION=${value}
+    elif [ "x${option}" = "x--with-lhapdf" ] ; then
+      LHAPDFLOCATION=${value}
+    elif [ "x${option}" = "x--with-lhapdflibname" ] ; then
+      LHAPDFLIBNAME=${value}
+    elif [ "x${option}" = "x--with-lhapdfsets" ] ; then
+      LHAPDFSETSLOCATION=${value}
+    elif [ "x${option}" = "x--with-fastjetversion" ] ; then
+      FASTJETVERSION=${value}
+    elif [ "x${option}" = "x--with-fastjet" ] ; then
+      FASTJETLOCATION=${value}
+    else
+      echo "${arg}: wrong option. Ignored." >&2
+    fi
+  else
+    echo "${arg}: wrong option. Ignored." >&2
+  fi
+done
+
+echo compilation mode is $COMPMODE
+
+
+# LHAPDF location
+# The default values here correspond to CERN AFS (but you may want to change
+# the version and/or platform).
+
+if [ x${LHAPDFLOCATION} != x ]; then
+  if [ x${LHAPDFSETSLOCATION} = x ]; then
+    export LHAPDFSETSLOCATION=${LHAPDFLOCATION}/../PDFsets
+    if [ ! -d ${LHAPDFSETSLOCATION} ]; then
+      export LHAPDFSETSLOCATION=${LHAPDFLOCATION}/../../share/lhapdf/PDFsets
+    fi
+    if [ ! -d ${LHAPDFSETSLOCATION} ]; then
+      export LHAPDFSETSLOCATION=${LHAPDFLOCATION}/../share/lhapdf/PDFsets
+    fi
+  fi
+fi
+if [ x${LHAPDFVERSION} = x ]; then
+  export LHAPDFVERSION=5.7.0
+else
+  if [ x${LHAPDFLOCATION} = x ]; then
+    export LHAPDFLOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/lhapdf/${LHAPDFVERSION}/${MYLCGPLATFORM}/lib/archive
+    if [ x${LHAPDFSETSLOCATION} = x ]; then
+      export LHAPDFSETSLOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/lhapdf/${LHAPDFVERSION}/share/PDFsets
+    fi
+  fi
+fi
+if [ x${LHAPDFLOCATION} = x ]; then
+  export LHAPDFLOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/lhapdf/${LHAPDFVERSION}/${MYLCGPLATFORM}/lib/archive
+fi
+if [ x${LHAPDFLIBNAME} = x ]; then
+  export LHAPDFLIBNAME="-lLHAPDF"
+fi
+if [ x${LHAPDFSETSLOCATION} = x ]; then
+  export LHAPDFSETSLOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/lhapdf/${LHAPDFVERSION}/share/PDFsets
+fi
+
+# Fastjet location
+if [ x${FASTJETVERSION} != x ]; then
+  export FASTJETLOCATION=/afs/cern.ch/sw/lcg/external/fastjet/${FASTJETVERSION}/${MYLCGPLATFORM}
+fi
+if [ x${FASTJETLOCATION} = x ]; then
+  export FASTJETLOCATION=/usr/local
+fi
+
+#
+# User-changeable part, experts  -----------------------------
+#
+
+# export FFLAGS_OPT="-O2 -Wuninitialized"
+# -Wuninitialized outputs many irrelevant warnings and therefore obscurs 
+export FFLAGS_OPT="-O2"
+export FFLAGS_DBG=-g
+export CFLAGS_OPT=-O2
+export CFLAGS_DBG=-g
+export CXXFLAGS_OPT="-O2 -ansi -pedantic -W -Wall"
+export CXXFLAGS_DBG="-g -ansi -pedantic -W -Wall"
+#
+# Find platform.
+#
+export ARCH0="`uname`"
+export ARCH=${ARCH0}
+export theGcc=`g++ --version | head -n 1 | awk '{print$3}' | awk -F . '{print $1}'`
+if [ ${theGcc} = 4 ]; then
+  export ARCH=${ARCH}-gcc4
+fi
+echo Platform is $ARCH
+
+#default platform settings:
+export FC=g77
+export CC=gcc
+export FFLAGS="${FFLAGS_OPT}"
+export CFLAGS="${CFLAGS_OPT}"
+export CXXFLAGS="${CXXFLAGS_OPT}"
+export FLIBS="-lfrtbegin -lg2c"
+if [ ${COMPMODE} = OPT ]; then
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+fi
+if [ ${COMPMODE} = DBG ]; then
+  export FFLAGS="${FFLAGS_DBG}"
+  export CFLAGS="${CFLAGS_DBG}"
+  export CXXFLAGS="${CXXFLAGS_DBG}"
+fi
+if [ $ARCH = Linux ]; then
+  export FC=g77
+  export FFLAGS="${FFLAGS_OPT} -Wno-globals"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lfrtbegin -lg2c"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG} -Wno-globals"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+fi
+# Linux platform with gcc4: new Fortran90 compiler.
+if [ $ARCH = Linux-gcc4 ]; then
+  export FC=gfortran
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lgfortran -lgfortranbegin"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+fi
+# Mac-OSX with gcc4
+if [ $ARCH = Darwin-gcc4 ]; then
+  export FC=gfortran
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lgfortran"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+fi
+# Mac-OSX with gcc3; is not tested
+if [ $ARCH = Darwin ]; then
+  export FC=g77
+  export FFLAGS="${FFLAGS_OPT}"
+  export CFLAGS="${CFLAGS_OPT}"
+  export CXXFLAGS="${CXXFLAGS_OPT}"
+  export FLIBS="-lfrtbegin -lg2c"
+  if [ ${COMPMODE} = OPT ]; then
+    export FFLAGS="${FFLAGS_OPT}"
+    export CFLAGS="${CFLAGS_OPT}"
+    export CXXFLAGS="${CXXFLAGS_OPT}"
+  fi
+  if [ ${COMPMODE} = DBG ]; then
+    export FFLAGS="${FFLAGS_DBG}"
+    export CFLAGS="${CFLAGS_DBG}"
+    export CXXFLAGS="${CXXFLAGS_DBG}"
+  fi
+fi
+
+#Platform & opt/dbg - independent flags and variables:
+
+
+#
+# End of the user-changeable part ---------------------------
+#
+# Checks
+#
+
+if [ ! -d ${PYTHIA8LOCATION}/lib ]; then
+  echo ERROR: pythia8 libraries not found at ${PYTHIA8LOCATION}/lib
+  exit
+fi
+
+if [ $?LHAPDFLOCATION ]; then
+  if [ x${LHAPDFLOCATION} != x ]; then
+    if [ ! -d ${LHAPDFLOCATION} ]; then
+      echo WARNING in LHAPDFLOCATION: directory ${LHAPDFLOCATION} does not exist
+      echo ...so you cannot run main programs that use LHAPDF 
+    fi
+    if [ ! -d ${LHAPDFSETSLOCATION} ]; then
+      echo WARNING in LHAPDFSETSLOCATION: directory ${LHAPDFSETSLOCATION} does not exist
+      echo ...so you cannot run main programs that use LHAPDF 
+    fi
+  fi
+fi
+
+# Fastjet
+if [ -x ${FASTJETLOCATION}/bin/fastjet-config ]; then
+  FASTJETVERSION1=`${FASTJETLOCATION}/bin/fastjet-config --version`
+  echo Found fastjet version ${FASTJETVERSION1} at ${FASTJETLOCATION}
+else
+  echo WARNING: FastJet not found, the corresponding examples will not work
+  echo ...so you cannot run main programs that use FastJet
+  export FASTJETLOCATION=
+fi
+
+rm -f config.mk
+
+echo SHELL = /bin/sh > config.mk
+#echo ARCH = ${ARCH} >> config.mk
+#echo MYLCGPLATFORM = ${MYLCGPLATFORM} >> config.mk
+#echo FC = ${FC} >> config.mk
+#echo CC = ${CC} >> config.mk
+#echo FFLAGS = ${FFLAGS} >> config.mk
+#echo CFLAGS = ${CFLAGS} >> config.mk
+#echo CXXFLAGS = ${CXXFLAGS} >> config.mk
+#echo FLIBS = ${FLIBS} >> config.mk
+#
+echo PYTHIA8LOCATION = ${PYTHIA8LOCATION} >> config.mk
+if [ x${LHAPDFVERSION} != x ]; then
+  echo LHAPDFVERSION = ${LHAPDFVERSION} >> config.mk
+fi
+if [ x${LHAPDFLOCATION} != x ]; then
+  echo LHAPDFLOCATION = ${LHAPDFLOCATION} >> config.mk
+fi
+if [ "x${LHAPDFLIBNAME}" != "x" ]; then
+  echo "LHAPDFLIBNAME = ${LHAPDFLIBNAME}" >> config.mk
+fi
+
+# Fastjet
+if [ "x${FASTJETLOCATION}" != "x" ]; then
+  echo "FASTJETLOCATION = ${FASTJETLOCATION}" >> config.mk
+fi
+
+
+#
+if [ ${PYTHIA8LOCATION} != .. ]; then
+  if [ ! -e config.csh ]; then
+    echo "#!/bin/csh" > config.csh
+    echo "setenv PYTHIA8DATA ${PYTHIA8LOCATION}/xmldoc" >> config.csh
+    echo "#!/bin/sh" > config.sh
+    echo "export PYTHIA8DATA=${PYTHIA8LOCATION}/xmldoc" >> config.sh
+  else
+    echo "setenv PYTHIA8DATA ${PYTHIA8LOCATION}/xmldoc" >> config.csh
+    echo "export PYTHIA8DATA=${PYTHIA8LOCATION}/xmldoc" >> config.sh
+  fi
+fi
+#
+# For the moment we take archive libraries of lhapdf, so actions with
+# LD_LIBRARY_PATH are not needed, this is for the future.
+# Setting LHAPATH is always needed
+# Linux platforms:
+if [ $ARCH0 != Darwin ]; then
+  if [ x${LHAPDFLOCATION} != x ]; then
+    if [ ! -e config.csh ]; then
+      echo "#!/bin/csh" > config.csh
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${LHAPDFLOCATION}" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.csh
+      echo "endif" >> config.csh
+      echo "setenv LHAPATH ${LHAPDFSETSLOCATION}" >> config.csh
+      echo "#!/bin/sh" > config.sh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo "export LHAPATH=${LHAPDFSETSLOCATION}" >> config.sh
+    else
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${LHAPDFLOCATION}" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.csh
+      echo "endif" >> config.csh
+      echo "setenv LHAPATH ${LHAPDFSETSLOCATION}" >> config.csh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo "export LHAPATH=${LHAPDFSETSLOCATION}" >> config.sh
+    fi
+  fi
+  if [ x${FASTJETLOCATION} != x ]; then
+    if [ ! -e config.csh ]; then
+      echo "#!/bin/csh" > config.csh
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${FASTJETLOCATION}/lib" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.csh
+      echo "endif" >> config.csh
+      echo "#!/bin/sh" > config.sh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+    else
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${FASTJETLOCATION}/lib" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.csh
+      echo "endif" >> config.csh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+    fi
+  fi
+# Mac-OSX platforms:
+else
+  if [ x${LHAPDFLOCATION} != x ]; then
+    if [ ! -e config.csh ]; then
+      echo "#!/bin/csh" > config.csh
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${LHAPDFLOCATION}" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.csh
+      echo "endif" >> config.csh
+      echo "setenv LHAPATH ${LHAPDFSETSLOCATION}" >> config.csh
+      echo "#!/bin/sh" > config.sh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo "export LHAPATH=${LHAPDFSETSLOCATION}" >> config.sh
+    else
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${LHAPDFLOCATION}" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.csh
+      echo "endif" >> config.csh
+      echo "setenv LHAPATH ${LHAPDFSETSLOCATION}" >> config.csh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${LHAPDFLOCATION}" >> config.sh
+      echo fi >> config.sh
+      echo "export LHAPATH=${LHAPDFSETSLOCATION}" >> config.sh
+    fi
+  fi
+  if [ x${FASTJETLOCATION} != x ]; then
+    if [ ! -e config.csh ]; then
+      echo "#!/bin/csh" > config.csh
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${FASTJETLOCATION}/lib" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.csh
+      echo "endif" >> config.csh
+      echo "#!/bin/sh" > config.sh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+    else
+      echo 'if( ! $?LD_LIBRARY_PATH ) then' >> config.csh
+      echo "  setenv LD_LIBRARY_PATH ${FASTJETLOCATION}/lib" >> config.csh
+      echo "else" >> config.csh
+      echo "  setenv LD_LIBRARY_PATH" '${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.csh
+      echo "endif" >> config.csh
+      echo 'if [ ! $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH=${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+      echo 'if [ $?LD_LIBRARY_PATH ]; then' >> config.sh
+      echo "  export LD_LIBRARY_PATH="'${LD_LIBRARY_PATH}'":${FASTJETLOCATION}/lib" >> config.sh
+      echo fi >> config.sh
+    fi
+  fi
+fi
diff --git a/PYTHIA8/pythia8170/examples/main01.cc b/PYTHIA8/pythia8170/examples/main01.cc
new file mode 100644 (file)
index 0000000..7442667
--- /dev/null
@@ -0,0 +1,33 @@
+// main01.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. It fits on one slide in a talk. 
+// It studies the charged multiplicity distribution at the LHC.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+  // Generator. Process selection. LHC initialization. Histogram.
+  Pythia pythia;
+  pythia.readString("Beams:eCM = 8000.");    
+  pythia.readString("HardQCD:all = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 20.");  
+  pythia.init();
+  Hist mult("charged multiplicity", 100, -0.5, 799.5);
+  // Begin event loop. Generate event. Skip if error. List first one.
+  for (int iEvent = 0; iEvent < 100; ++iEvent) {
+    if (!pythia.next()) continue;
+    // Find number of all final charged particles and fill histogram.
+    int nCharged = 0;
+    for (int i = 0; i < pythia.event.size(); ++i) 
+      if (pythia.event[i].isFinal() && pythia.event[i].isCharged()) 
+        ++nCharged; 
+    mult.fill( nCharged );
+  // End of event loop. Statistics. Histogram. Done.
+  }
+  pythia.stat();
+  cout << mult; 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main02.cc b/PYTHIA8/pythia8170/examples/main02.cc
new file mode 100644 (file)
index 0000000..cc652f9
--- /dev/null
@@ -0,0 +1,34 @@
+// main02.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. It fits on one slide in a talk.
+// It studies the pT_Z spectrum at the Tevatron.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+  // Generator. Process selection. Tevatron initialization. Histogram.
+  Pythia pythia;
+  pythia.readString("Beams:idB = -2212");    
+  pythia.readString("Beams:eCM = 1960.");    
+  pythia.readString("WeakSingleBoson:ffbar2gmZ = on");    
+  pythia.readString("PhaseSpace:mHatMin = 80.");    
+  pythia.readString("PhaseSpace:mHatMax = 120.");    
+  pythia.init();
+  Hist pTZ("dN/dpTZ", 100, 0., 100.);
+  // Begin event loop. Generate event. Skip if error. List first one.
+  for (int iEvent = 0; iEvent < 1000; ++iEvent) {
+    if (!pythia.next()) continue;
+    // Loop over particles in event. Find last Z0 copy. Fill its pT. 
+    int iZ = 0;
+    for (int i = 0; i < pythia.event.size(); ++i) 
+      if (pythia.event[i].id() == 23) iZ = i;
+    pTZ.fill( pythia.event[iZ].pT() );
+  // End of event loop. Statistics. Histogram. Done.
+  }
+  pythia.stat();
+  cout << pTZ; 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main03.cc b/PYTHIA8/pythia8170/examples/main03.cc
new file mode 100644 (file)
index 0000000..45e4127
--- /dev/null
@@ -0,0 +1,94 @@
+// main03.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates how different processes can be selected and studied.
+// All input is specified in the main03.cmnd file.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Generator.
+  Pythia pythia;
+
+  // Shorthand for the event record in pythia.
+  Event& event = pythia.event;
+
+  // Read in commands from external file.
+  pythia.readFile("main03.cmnd");    
+
+  // Extract settings to be used in the main program.
+  int nEvent = pythia.mode("Main:numberOfEvents");
+  int nAbort = pythia.mode("Main:timesAllowErrors");
+
+  // Initialize. 
+  pythia.init();
+
+  // Book histograms.
+  Hist pThard("process pT scale", 100, 0., 500.);
+  Hist nFinal("final particle multiplicity", 100, -0.5, 1599.5);
+  Hist nCharged("charged particle multiplicity", 100, -0.5, 799.5);
+  Hist dndy("dn/dy for charged particles", 100, -10., 10.);
+  Hist dndeta("dn/d(eta) for charged particles", 100, -10., 10.);
+  Hist dndpT("dn/dpT for charged particles", 100, 0., 10.);
+  Hist epCons("deviation from energy-momentum conservation", 100, 0., 1e-6);
+
+  // Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+
+    // Fill hard scale of event.
+    pThard.fill( pythia.info.pTHat() );
+
+    // Loop over final particles in the event. 
+    int  nFin = 0;
+    int  nChg = 0;
+    Vec4 pSum;
+    for (int i = 0; i < event.size(); ++i) if (event[i].isFinal()) {
+
+       // Analyze all particles.
+      nFin++;
+      pSum += event[i].p();
+       
+      // Analyze charged particles and fill histograms.
+      if (event[i].isCharged()) {
+        ++nChg;
+        dndy.fill( event[i].y() );
+        dndeta.fill( event[i].eta() );
+        dndpT.fill( event[i].pT() );
+      }
+
+    // End of particle loop. Fill global properties.
+    }
+    nFinal.fill( nFin );
+    nCharged.fill( nChg );
+    pSum /= event[0].e();
+    double epDev = abs(pSum.e() - 1.) + abs(pSum.px()) + abs(pSum.py())
+      + abs(pSum.pz());
+    epCons.fill(epDev);
+
+  // End of event loop.
+  }
+   
+  // Final statistics. Normalize and output histograms.
+  pythia.stat();
+  dndy   *=  5. / nEvent;
+  dndeta *=  5. / nEvent;
+  dndpT  *= 10. / nEvent;
+  cout << pThard << nFinal << nCharged << dndy << dndeta << dndpT << epCons; 
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main03.cmnd b/PYTHIA8/pythia8170/examples/main03.cmnd
new file mode 100644 (file)
index 0000000..747f664
--- /dev/null
@@ -0,0 +1,55 @@
+! main03.cmnd.
+! This file contains commands to be read in for a Pythia8 run. 
+! Lines not beginning with a letter or digit are comments.
+! Names are case-insensitive  -  but spellings-sensitive!
+! The settings here are illustrative, not always physics-motivated.
+
+! 1) Settings used in the main program.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:timesAllowErrors = 3          ! how many aborts before run stops
+
+! 2) Settings related to output in init(), next() and stat().
+Init:showChangedSettings = on      ! list changed settings
+Init:showChangedParticleData = off ! list changed particle data
+Next:numberCount = 100             ! print message every n events
+Next:numberShowInfo = 1            ! print event information n times
+Next:numberShowProcess = 1         ! print process record n times
+Next:numberShowEvent = 0           ! print event record n times
+
+! 3) Beam parameter settings. Values below agree with default ones.
+Beams:idA = 2212                   ! first beam, p = 2212, pbar = -2212
+Beams:idB = 2212                   ! second beam, p = 2212, pbar = -2212
+Beams:eCM = 14000.                 ! CM energy of collision
+
+! 4) Settings for the hard-process generation.
+
+! Example 1: QCD + prompt photon production; must set pTmin. 
+HardQCD:all = on                   ! switch on all QCD jet + jet processes
+PromptPhoton:all = on              ! swich on gamma + jet and gamma + gamma 
+PhaseSpace:pTHatMin = 50.          ! minimal pT scale in process 
+
+! Example 2: t-tbar production.  
+#Top:gg2ttbar = on                  ! g g -> t tbar
+#Top:qqbar2ttbar = on               ! q qbar -> t tbar
+
+! Example 3: Z0 production; should set mMin.
+#WeakSingleBoson:ffbar2gmZ = on     ! q qbar -> gamma*/Z0
+#PhaseSpace:mHatMin = 50.            
+
+! Example 4: gauge boson pair production; set pTmin. Not yet complete.
+#WeakDoubleBoson:ffbar2ZW = on      ! q qbar -> Z0 W+- 
+#WeakDoubleBoson:ffbar2WW = on      ! q qbar -> W+ W-
+#PhaseSpace:pTHatMin = 20.          ! minimal pT scale in process 
+
+! 5) Switch on/off the key event generation steps. 
+#PartonLevel:MPI = off              ! no multiparton interactions
+#PartonLevel:ISR = off              ! no initial-state radiation 
+#PartonLevel:FSR = off              ! no final-state radiation
+#HadronLevel:Hadronize = off        ! no hadronization
+#HadronLevel:Decay = off            ! no decays
+
+! 6) Other settings. Can be expanded as desired.
+#Tune:preferLHAPDF = off            ! use internal PDFs when LHAPDF not linked
+Tune:pp = 6                        ! use Tune 4Cx
+ParticleDecays:limitTau0 = on      ! set long-lived particle stable ...
+ParticleDecays:tau0Max = 10        ! ... if c*tau0 > 10 mm
diff --git a/PYTHIA8/pythia8170/examples/main04.cc b/PYTHIA8/pythia8170/examples/main04.cc
new file mode 100644 (file)
index 0000000..6a9f2cb
--- /dev/null
@@ -0,0 +1,216 @@
+// main04.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates how to generate and study "total cross section" processes,
+// i.e. elastic, single and double diffractive, and the "minimum-bias" rest.
+// All input is specified in the main06.cmnd file.
+// Note that the "total" cross section does NOT include 
+// the Coulomb contribution to elastic scattering, as switched on here.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+int main() {
+
+  // Generator. Shorthand for the event.
+  Pythia pythia;
+  Event& event = pythia.event;
+
+  // Read in commands from external file.
+  pythia.readFile("main04.cmnd");    
+
+  // Extract settings to be used in the main program.
+  int    nEvent    = pythia.mode("Main:numberOfEvents");
+  int    nAbort    = pythia.mode("Main:timesAllowErrors");
+  // Initialize. 
+  pythia.init();
+
+  // Book histograms: multiplicities and mean transverse momenta.
+  Hist yChg("rapidity of charged particles; all",      100, -10., 10.);
+  Hist nChg("number of charged particles; all",        100, -0.5, 799.5);
+  Hist nChgSD("number of charged particles; single diffraction", 
+                                                       100, -0.5, 799.5);
+  Hist nChgDD("number of charged particles, double diffractive", 
+                                                       100, -0.5, 799.5);
+  Hist nChgCD("number of charged particles, central diffractive", 
+                                                       100, -0.5, 799.5);
+  Hist nChgND("number of charged particles, non-diffractive", 
+                                                       100, -0.5, 799.5);
+  Hist pTnChg("<pt>(n_charged) all",                   100, -0.5, 799.5);
+  Hist pTnChgSD("<pt>(n_charged) single diffraction",  100, -0.5, 799.5);
+  Hist pTnChgDD("<pt>(n_charged) double diffraction",  100, -0.5, 799.5);
+  Hist pTnChgCD("<pt>(n_charged) central diffraction", 100, -0.5, 799.5);
+  Hist pTnChgND("<pt>(n_charged) non-diffractive   ",  100, -0.5, 799.5);
+
+  // Book histograms: ditto as function of separate subsystem mass.
+  Hist mLogInel("log10(mass), by diffractive system",  100, 0., 5.);
+  Hist nChgmLog("<n_charged>(log10(mass))",            100, 0., 5.);
+  Hist pTmLog("<pT>_charged>(log10(mass))",            100, 0., 5.);
+
+  // Book histograms: elastic/diffractive.
+  Hist tSpecEl("elastic |t| spectrum",              100, 0., 1.);
+  Hist tSpecElLog("elastic log10(|t|) spectrum",    100, -5., 0.);
+  Hist tSpecSD("single diffractive |t| spectrum",   100, 0., 2.); 
+  Hist tSpecDD("double diffractive |t| spectrum",   100, 0., 5.); 
+  Hist tSpecCD("central diffractive |t| spectrum",  100, 0., 5.); 
+  Hist mSpec("diffractive mass spectrum",           100, 0., 100.); 
+  Hist mLogSpec("log10(diffractive mass spectrum)", 100, 0., 4.); 
+
+  // Book histograms: inelastic nondiffractive "minbias".
+  double pTmax = 20.;
+  double bMax  = 4.;
+  Hist pTspec("total pT_hard spectrum",             100, 0., pTmax); 
+  Hist pTspecND("nondiffractive pT_hard spectrum",  100, 0., pTmax); 
+  Hist bSpec("b impact parameter spectrum",         100, 0., bMax);
+  Hist enhanceSpec("b enhancement spectrum",        100, 0., 10.);
+  Hist number("number of interactions",             100, -0.5, 99.5);
+  Hist pTb1("pT spectrum for b < 0.5",              100, 0., pTmax); 
+  Hist pTb2("pT spectrum for 0.5 < b < 1",          100, 0., pTmax); 
+  Hist pTb3("pT spectrum for 1 < b < 1.5",          100, 0., pTmax); 
+  Hist pTb4("pT spectrum for 1.5 < b",              100, 0., pTmax); 
+  Hist bpT1("b spectrum for pT < 2",                100, 0., bMax);
+  Hist bpT2("b spectrum for 2 < pT < 5",            100, 0., bMax);
+  Hist bpT3("b spectrum for 5 < pT < 15",           100, 0., bMax);
+  Hist bpT4("b spectrum for 15 < pT",               100, 0., bMax);
+  // Begin event loop.
+  int iAbort = 0; 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Generate events. Quit if too many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+
+    // Extract event classification.
+    int code = pythia.info.code();
+    
+    // Charged multiplicity and mean pT: all and by event class.
+    int nch = 0;
+    double pTsum = 0.; 
+    for (int i = 1; i < event.size(); ++i)
+    if (event[i].isFinal() && event[i].isCharged()) {
+      yChg.fill( event[i].y() );
+      ++nch; 
+      pTsum += event[i].pT();
+    }
+    nChg.fill( nch );
+    if (nch > 0) pTnChg.fill( nch, pTsum/nch);
+    if (code == 103 || code == 104) {
+      nChgSD.fill( nch );
+      if (nch > 0) pTnChgSD.fill( nch, pTsum/nch);
+    } else if (code == 105) {
+      nChgDD.fill( nch );
+      if (nch > 0) pTnChgDD.fill( nch, pTsum/nch);
+    } else if (code == 106) {
+      nChgCD.fill( nch );
+      if (nch > 0) pTnChgCD.fill( nch, pTsum/nch);
+    } else if (code == 101) {
+      nChgND.fill( nch );
+      if (nch > 0) pTnChgND.fill( nch, pTsum/nch);
+      double mLog = log10( event[0].m() ); 
+      mLogInel.fill( mLog );  
+      nChgmLog.fill( mLog, nch );  
+      if (nch > 0) pTmLog.fill( mLog, pTsum / nch );  
+    }
+
+    // Charged multiplicity and mean pT: per diffractive system.
+    for (int iDiff = 0; iDiff < 3; ++iDiff) 
+    if ( (iDiff == 0 && pythia.info.isDiffractiveA()) 
+      || (iDiff == 1 && pythia.info.isDiffractiveB()) 
+      || (iDiff == 2 && pythia.info.isDiffractiveC()) ) {
+      int ndiff = 0;
+      double pTdiff = 0.;
+      int nDoc = (iDiff < 2) ? 4 : 5;   
+      for (int i = nDoc + 1; i < event.size(); ++i) 
+      if (event[i].isFinal() && event[i].isCharged()) {
+        // Trace back final particle to see which system it comes from.
+        int k = i;
+        do k = event[k].mother1(); 
+        while (k > nDoc);
+        if (k == iDiff + 3) {
+          ++ndiff;
+          pTdiff += event[i].pT();
+        }
+      } 
+      // Study diffractive mass spectrum.
+      double mDiff = event[iDiff+3].m();
+      double mLog  = log10( mDiff);  
+      mLogInel.fill( mLog );  
+      nChgmLog.fill( mLog, ndiff );  
+      if (ndiff > 0) pTmLog.fill( mLog, pTdiff / ndiff );  
+      mSpec.fill( mDiff );  
+      mLogSpec.fill( mLog );
+    }
+
+    // Study pT spectrum of all hard collisions, no distinction.
+    double pT = pythia.info.pTHat();
+    pTspec.fill( pT );
+
+    // Study t distribution of elastic/diffractive events.
+    if (code > 101) {
+      double tAbs = abs(pythia.info.tHat());
+      if (code == 102) {
+        tSpecEl.fill(tAbs);
+        tSpecElLog.fill(log10(tAbs));
+      }
+      else if (code == 103 || code == 104) tSpecSD.fill(tAbs);
+      else if (code == 105) tSpecDD.fill(tAbs);
+      else if (code == 106) {
+        double t1Abs = abs( (event[3].p() - event[1].p()).m2Calc() );
+        double t2Abs = abs( (event[4].p() - event[2].p()).m2Calc() );
+        tSpecCD.fill(t1Abs);
+        tSpecCD.fill(t2Abs);
+      }
+
+    // Study nondiffractive inelastic events in (pT, b) space.
+    } else {
+      double b = pythia.info.bMPI();
+      double enhance = pythia.info.enhanceMPI();
+      int nMPI = pythia.info.nMPI();
+      pTspecND.fill( pT );
+      bSpec.fill( b );
+      enhanceSpec.fill( enhance );
+      number.fill( nMPI );
+      if (b < 0.5) pTb1.fill( pT );
+      else if (b < 1.0) pTb2.fill( pT );
+      else if (b < 1.5) pTb3.fill( pT );
+      else pTb4.fill( pT );
+      if (pT < 2.) bpT1.fill( b );
+      else if (pT < 5.) bpT2.fill( b );
+      else if (pT < 15.) bpT3.fill( b );
+      else bpT4.fill( b );
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics and histograms.
+  pythia.stat();
+  pTnChg   /= nChg;
+  pTnChgSD /= nChgSD;
+  pTnChgDD /= nChgDD;
+  pTnChgCD /= nChgCD;
+  pTnChgND /= nChgND;
+  nChgmLog /= mLogInel;
+  pTmLog   /= mLogInel;
+  cout << yChg << nChg << nChgSD << nChgDD << nChgCD << nChgND
+       << pTnChg << pTnChgSD << pTnChgDD << pTnChgCD << pTnChgND
+       << mLogInel << nChgmLog << pTmLog
+       << tSpecEl << tSpecElLog << tSpecSD << tSpecDD << tSpecCD
+       << mSpec << mLogSpec 
+       << pTspec << pTspecND << bSpec << enhanceSpec << number
+       << pTb1 << pTb2 << pTb3 << pTb4 << bpT1 << bpT2 << bpT3 << bpT4;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main04.cmnd b/PYTHIA8/pythia8170/examples/main04.cmnd
new file mode 100644 (file)
index 0000000..bb574ef
--- /dev/null
@@ -0,0 +1,58 @@
+! File: main04.cmnd
+! This file contains commands to be read in for a Pythia8 run. 
+! Lines not beginning with a letter or digit are comments.
+! Names are case-insensitive  -  but spellings-sensitive!
+! The changes here are illustrative, not always physics-motivated.
+
+! 1) Settings used in the main program.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:timesAllowErrors = 10         ! how many aborts before run stops
+
+! 2) Settings related to output in init(), next() and stat().
+Init:showChangedSettings = on      ! list changed settings
+Init:showChangedParticleData = off ! list changed particle data
+Next:numberCount = 500             ! print message every n events
+Next:numberShowInfo = 3            ! print event information n times
+Next:numberShowProcess = 0         ! print process record n times
+Next:numberShowEvent = 0           ! print event record n times
+
+! 3) Beam parameter settings. Values below agree with default ones.
+Beams:idA = 2212                   ! first beam, p = 2212, pbar = -2212
+Beams:idB = 2212                   ! second beam, p = 2212, pbar = -2212
+Beams:eCM = 14000.                 ! CM energy of collision
+
+! 4) Settings for the hard-process generation.
+SoftQCD:all = on                   ! Allow total sigma = elastic/SD/DD/ND
+! Optionally only study one or a few processes at a time.
+#SoftQCD:elastic = on               ! Elastic
+#SoftQCD:singleDiffractive = on     ! Single diffractive
+#SoftQCD:doubleDiffractive = on     ! Double diffractive
+#SoftQCD:centralDiffractive = on    ! Central diffractive
+#SoftQCD:minbias = on               ! Nondiffractive inelastic
+
+! 5) Optionally switch on hand-set cross section and Coulomb term.
+! Note: these values are illustrative only, not to be taken seriously.
+#SigmaTotal:setOwn = on             ! set your own total/elastic/diffr. sigma
+#SigmaTotal:sigmaTot = 106.         ! total cross section (excluding Coulomb)
+#SigmaTotal:sigmaXX = 5.            ! reduce double diffractive cross section 
+#SigmaElastic:setOwn = on           ! suboption for Coulomb term in elastic
+#SigmaElastic:tAbsMin = 4e-5        ! divergence requires lower cutoff
+
+! 6) Optionally select diffractive model.
+Diffraction:PomFlux = 5             ! the MBR model for diffraction
+
+! 7) Multiparton interactions and impact parameter picture.
+! Note: these values are illustrative only, not to be taken seriously.
+MultipartonInteractions:pT0Ref = 2.
+MultipartonInteractions:ecmRef = 1960.
+MultipartonInteractions:ecmPow = 0.16
+MultipartonInteractions:pTmin = 0.2
+MultipartonInteractions:bProfile = 2   
+#MultipartonInteractions:coreRadius = 0.4
+#MultipartonInteractions:coreFraction = 0.5
+MultipartonInteractions:expPow = 1.
+
+! 8) Other settings. Can be expanded as desired. 
+! Note: may overwrite some of the values above, so watch out.
+#Tune:pp = 6                         ! use Tune 4Cx
+
diff --git a/PYTHIA8/pythia8170/examples/main05.cc b/PYTHIA8/pythia8170/examples/main05.cc
new file mode 100644 (file)
index 0000000..e6a611f
--- /dev/null
@@ -0,0 +1,134 @@
+// main05.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It studies jet production at the LHC, using SlowJet and CellJet.
+// Note: the two finders are intended to construct approximately the same
+// jet properties, but provides output in slightly different format, 
+// and have here not been optimized to show maximum possible agreement.
+
+#include "Pythia.h"
+using namespace Pythia8;
+int main() {
+
+  // Number of events, generated and listed ones.
+  int nEvent    = 500;
+  int nListJets = 5;
+
+  // Generator. LHC process and output selection. Initialization.
+  Pythia pythia;
+  pythia.readString("Beams:eCM = 14000.");    
+  pythia.readString("HardQCD:all = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 200.");    
+  pythia.readString("Next:numberShowInfo = 0");
+  pythia.readString("Next:numberShowProcess = 0");
+  pythia.readString("Next:numberShowEvent = 0"); 
+  pythia.init();
+
+  // Common parameters for the two jet finders.
+  double etaMax   = 4.;
+  double radius   = 0.7;
+  double pTjetMin = 10.;
+  // Exclude neutrinos (and other invisible) from study.
+  int    nSel     = 2;
+  // Range and granularity of CellJet jet finder.
+  int    nEta     = 80;
+  int    nPhi     = 64;
+
+  // Set up SlowJet jet finder, with anti-kT clustering
+  // and pion mass assumed for non-photons..
+  SlowJet slowJet( -1, radius, pTjetMin, etaMax, nSel, 1);
+
+  // Set up CellJet jet finder. 
+  CellJet cellJet( etaMax, nEta, nPhi, nSel);
+
+  // Histograms. Note similarity in names, even when the two jet finders
+  // do not calculate identically the same property (pT vs. ET, y vs. eta).
+  Hist nJetsS("number of jets, SlowJet", 50, -0.5, 49.5);
+  Hist nJetsC("number of jets, CellJet", 50, -0.5, 49.5);
+  Hist nJetsD("number of jets, CellJet - SlowJet", 45, -22.5, 22.5);
+  Hist eTjetsS("pT for jets, SlowJet", 100, 0., 500.);
+  Hist eTjetsC("eT for jets, CellJet", 100, 0., 500.);
+  Hist etaJetsS("y for jets, SlowJet", 100, -5., 5.);
+  Hist etaJetsC("eta for jets, CellJet", 100, -5., 5.);
+  Hist phiJetsS("phi for jets, SlowJwt", 100, -M_PI, M_PI);  
+  Hist phiJetsC("phi for jets, CellJet", 100, -M_PI, M_PI);  
+  Hist distJetsS("R distance between jets, SlowJet", 100, 0., 10.);
+  Hist distJetsC("R distance between jets, CellJet", 100, 0., 10.);
+  Hist eTdiffS("pT difference, SlowJet", 100, -100., 400.);
+  Hist eTdiffC("eT difference, CellJet", 100, -100., 400.);
+
+  // Begin event loop. Generate event. Skip if error. 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (!pythia.next()) continue;
+
+    // Analyze Slowet jet properties. List first few. 
+    slowJet. analyze( pythia.event );
+    if (iEvent < nListJets) slowJet.list();
+
+    // Fill SlowJet inclusive jet distributions.
+    nJetsS.fill( slowJet.sizeJet() );
+    for (int i = 0; i < slowJet.sizeJet(); ++i) {
+      eTjetsS.fill( slowJet.pT(i) );
+      etaJetsS.fill( slowJet.y(i) );
+      phiJetsS.fill( slowJet.phi(i) );
+    }
+
+    // Fill SlowJet distance between jets.
+    for (int i = 0; i < slowJet.sizeJet() - 1; ++i)
+    for (int j = i +1; j < slowJet.sizeJet(); ++j) {
+      double dEta = slowJet.y(i) - slowJet.y(j);
+      double dPhi = abs( slowJet.phi(i) - slowJet.phi(j) );
+      if (dPhi > M_PI) dPhi = 2. * M_PI - dPhi;
+      double dR = sqrt( pow2(dEta) + pow2(dPhi) );
+      distJetsS.fill( dR );
+    }
+
+    // Fill SlowJet pT-difference between jets (to check ordering of list).
+    for (int i = 1; i < slowJet.sizeJet(); ++i) 
+      eTdiffS.fill( slowJet.pT(i-1) - slowJet.pT(i) );
+
+    // Analyze CellJet jet properties. List first few. 
+    cellJet. analyze( pythia.event, pTjetMin, radius );
+    if (iEvent < nListJets) cellJet.list();
+
+    // Fill CellJet inclusive jet distributions.
+    nJetsC.fill( cellJet.size() );
+    for (int i = 0; i < cellJet.size(); ++i) {
+      eTjetsC.fill( cellJet.eT(i) );
+      etaJetsC.fill( cellJet.etaWeighted(i) );
+      phiJetsC.fill( cellJet.phiWeighted(i) );
+    }
+
+    // Fill CellJet distance between jets.
+    for (int i = 0; i < cellJet.size() - 1; ++i)
+    for (int j = i +1; j < cellJet.size(); ++j) {
+      double dEta = cellJet.etaWeighted(i) 
+        - cellJet.etaWeighted(j);
+      double dPhi = abs( cellJet.phiWeighted(i) 
+        - cellJet.phiWeighted(j) );
+      if (dPhi > M_PI) dPhi = 2. * M_PI - dPhi;
+      double dR = sqrt( pow2(dEta) + pow2(dPhi) );
+      distJetsC.fill( dR );
+    }
+
+    // Fill CellJet ET-difference between jets (to check ordering of list).
+    for (int i = 1; i < cellJet.size(); ++i) 
+      eTdiffC.fill( cellJet.eT(i-1) - cellJet.eT(i) );
+
+    // Compare number of jets for the two finders.
+    nJetsD.fill( cellJet.size() - slowJet.sizeJet() );
+
+  // End of event loop. Statistics. Histograms. 
+  }
+  pythia.stat();
+  cout << nJetsS << nJetsC << nJetsD << eTjetsS << eTjetsC 
+       << etaJetsS << etaJetsC << phiJetsS << phiJetsC 
+       << distJetsS << distJetsC << eTdiffS << eTdiffC;
+
+  // Done. 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main06.cc b/PYTHIA8/pythia8170/examples/main06.cc
new file mode 100644 (file)
index 0000000..ba87fc9
--- /dev/null
@@ -0,0 +1,138 @@
+// main06.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It studies event properties of LEP1 events.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Generator.
+  Pythia pythia;
+
+  // Allow no substructure in e+- beams: normal for corrected LEP data.
+  pythia.readString("PDF:lepton = off"); 
+  // Process selection.
+  pythia.readString("WeakSingleBoson:ffbar2gmZ = on");    
+  // Switch off all Z0 decays and then switch back on those to quarks.
+  pythia.readString("23:onMode = off"); 
+  pythia.readString("23:onIfAny = 1 2 3 4 5"); 
+
+  // LEP1 initialization at Z0 mass. 
+  pythia.readString("Beams:idA =  11"); 
+  pythia.readString("Beams:idB = -11"); 
+  double mZ = pythia.particleData.m0(23); 
+  pythia.settings.parm("Beams:eCM", mZ);
+  pythia.init();
+
+  // Histograms.
+  Hist nCharge("charged multiplicity", 100, -0.5, 99.5);
+  Hist spheri("Sphericity", 100, 0., 1.);
+  Hist linea("Linearity", 100, 0., 1.);
+  Hist thrust("thrust", 100, 0.5, 1.);
+  Hist oblateness("oblateness", 100, 0., 1.);
+  Hist sAxis("cos(theta_Sphericity)", 100, -1., 1.);
+  Hist lAxis("cos(theta_Linearity)", 100, -1., 1.);
+  Hist tAxis("cos(theta_Thrust)", 100, -1., 1.);
+  Hist nLund("Lund jet multiplicity", 40, -0.5, 39.5);
+  Hist nJade("Jade jet multiplicity", 40, -0.5, 39.5);
+  Hist nDurham("Durham jet multiplicity", 40, -0.5, 39.5);
+  Hist eDifLund("Lund e_i - e_{i+1}", 100, -5.,45.);
+  Hist eDifJade("Jade e_i - e_{i+1}", 100, -5.,45.);
+  Hist eDifDurham("Durham e_i - e_{i+1}", 100, -5.,45.);
+
+  // Set up Sphericity, "Linearity", Thrust and cluster jet analyses.
+  Sphericity sph;  
+  Sphericity lin(1.);
+  Thrust thr;
+  ClusterJet lund("Lund"); 
+  ClusterJet jade("Jade"); 
+  ClusterJet durham("Durham"); 
+
+  // Begin event loop. Generate event. Skip if error. List first few.
+  for (int iEvent = 0; iEvent < 10000; ++iEvent) {
+    if (!pythia.next()) continue;
+
+    // Find and histogram charged multiplicity. 
+    int nCh = 0;
+    for (int i = 0; i < pythia.event.size(); ++i) 
+      if (pythia.event[i].isFinal() && pythia.event[i].isCharged()) ++nCh;
+    nCharge.fill( nCh );
+
+    // Find and histogram sphericity. 
+    if (sph.analyze( pythia.event )) { 
+      if (iEvent < 3) sph.list();
+      spheri.fill( sph.sphericity() ); 
+      sAxis.fill( sph.eventAxis(1).pz() );
+      double e1 = sph.eigenValue(1);
+      double e2 = sph.eigenValue(2);
+      double e3 = sph.eigenValue(3);
+      if (e2 > e1 || e3 > e2) cout << "eigenvalues out of order: "
+      << e1 << "  " << e2 << "  " << e3 << endl;
+    }
+
+    // Find and histogram linearized sphericity. 
+    if (lin.analyze( pythia.event )) {
+      if (iEvent < 3) lin.list();
+      linea.fill( lin.sphericity() ); 
+      lAxis.fill( lin.eventAxis(1).pz() );
+      double e1 = lin.eigenValue(1);
+      double e2 = lin.eigenValue(2);
+      double e3 = lin.eigenValue(3);
+      if (e2 > e1 || e3 > e2) cout << "eigenvalues out of order: "
+      << e1 << "  " << e2 << "  " << e3 << endl;
+    }
+
+    // Find and histogram thrust.
+    if (thr.analyze( pythia.event )) {
+      if (iEvent < 3) thr.list();
+      thrust.fill( thr.thrust() );
+      oblateness.fill( thr.oblateness() );
+      tAxis.fill( thr.eventAxis(1).pz() );
+      if ( abs(thr.eventAxis(1).pAbs() - 1.) > 1e-8 
+        || abs(thr.eventAxis(2).pAbs() - 1.) > 1e-8 
+        || abs(thr.eventAxis(3).pAbs() - 1.) > 1e-8 
+        || abs(thr.eventAxis(1) * thr.eventAxis(2)) > 1e-8
+        || abs(thr.eventAxis(1) * thr.eventAxis(3)) > 1e-8
+        || abs(thr.eventAxis(2) * thr.eventAxis(3)) > 1e-8 ) {
+        cout << " suspicious Thrust eigenvectors " << endl;
+        thr.list();
+      }
+    }
+
+    // Find and histogram cluster jets: Lund, Jade and Durham distance. 
+    if (lund.analyze( pythia.event, 0.01, 0.)) {
+      if (iEvent < 3) lund.list();
+      nLund.fill( lund.size() );
+      for (int j = 0; j < lund.size() - 1; ++j)
+        eDifLund.fill( lund.p(j).e() - lund.p(j+1).e() ); 
+    } 
+    if (jade.analyze( pythia.event, 0.01, 0.)) {
+      if (iEvent < 3) jade.list();
+      nJade.fill( jade.size() );
+      for (int j = 0; j < jade.size() - 1; ++j)
+        eDifJade.fill( jade.p(j).e() - jade.p(j+1).e() ); 
+    } 
+    if (durham.analyze( pythia.event, 0.01, 0.)) {
+      if (iEvent < 3) durham.list();
+      nDurham.fill( durham.size() );
+      for (int j = 0; j < durham.size() - 1; ++j)
+        eDifDurham.fill( durham.p(j).e() - durham.p(j+1).e() ); 
+    } 
+
+  // End of event loop. Statistics. Output histograms. 
+  }
+  pythia.stat();
+  cout << nCharge << spheri << linea << thrust << oblateness 
+       << sAxis << lAxis << tAxis
+       << nLund << nJade << nDurham
+       << eDifLund << eDifJade << eDifDurham; 
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main07.cc b/PYTHIA8/pythia8170/examples/main07.cc
new file mode 100644 (file)
index 0000000..4d1545f
--- /dev/null
@@ -0,0 +1,110 @@
+// main07.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Illustration how to generate various two-body channels from 
+// astroparticle processes, e.g. neutralino annihilation or decay.
+// To this end a "blob" of energy is created with unit cross section,
+// from the fictitious collision of two non-radiating incoming e+e-.
+// In the accompanying main29.cmnd file the decay channels of this
+// blob can be set up. Furthermore, only gamma, e+-, p/pbar and
+// neutrinos are stable, everything else is set to decay.
+// (The "single-particle gun" of main21.cc offers another possible 
+// approach to the same problem.) 
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+//==========================================================================
+
+// A derived class for (e+ e- ->) GenericResonance -> various final states.
+
+class Sigma1GenRes : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1GenRes() {}
+
+  // Evaluate sigmaHat(sHat): dummy unit cross section. 
+  virtual double sigmaHat() {return 1.;}
+
+  // Select flavour. No colour or anticolour.
+  virtual void setIdColAcol() {setId( -11, 11, 999999);
+    setColAcol( 0, 0, 0, 0, 0, 0);}
+
+  // Info on the subprocess.
+  virtual string name()    const {return "GenericResonance";}
+  virtual int    code()    const {return 9001;}
+  virtual string inFlux()  const {return "ffbarSame";}
+
+};
+
+//==========================================================================
+
+int main() {
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // A class to generate the fictitious resonance initial state. 
+  SigmaProcess* sigma1GenRes = new Sigma1GenRes();
+
+  // Hand pointer to Pythia.
+  pythia.setSigmaPtr( sigma1GenRes);
+
+  // Read in the rest of the settings and data from a separate file.
+  pythia.readFile("main07.cmnd");
+
+  // Initialization.
+  pythia.init();
+
+  // Extract settings to be used in the main program.
+  int nEvent  = pythia.mode("Main:numberOfEvents");
+  int nAbort  = pythia.mode("Main:timesAllowErrors");
+
+  // Histogram particle spectra.
+  Hist eGamma("energy spectrum of photons",        100, 0., 250.);
+  Hist eE(    "energy spectrum of e+ and e-",      100, 0., 250.);
+  Hist eP(    "energy spectrum of p and pbar",     100, 0., 250.);
+  Hist eNu(   "energy spectrum of neutrinos",      100, 0., 250.);
+  Hist eRest( "energy spectrum of rest particles", 100, 0., 250.);
+
+  // Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+
+    // Loop over all particles and analyze the final-state ones.
+    for (int i = 0; i < pythia.event.size(); ++i) 
+    if (pythia.event[i].isFinal()) {
+      int idAbs = pythia.event[i].idAbs();
+      double eI = pythia.event[i].e();
+      if (idAbs == 22) eGamma.fill(eI);
+      else if (idAbs == 11) eE.fill(eI);
+      else if (idAbs == 2212) eP.fill(eI);
+      else if (idAbs == 12 || idAbs == 14 || idAbs == 16) eNu.fill(eI);
+      else {
+        eRest.fill(eI);
+        cout << " Error: stable id = " << pythia.event[i].id() << endl;
+      }
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics and histograms.
+  pythia.stat();
+  cout << eGamma << eE << eP << eNu << eRest;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main07.cmnd b/PYTHIA8/pythia8170/examples/main07.cmnd
new file mode 100644 (file)
index 0000000..4db4f14
--- /dev/null
@@ -0,0 +1,40 @@
+! main07.cmnd.
+! This file contains commands to be read in for a Pythia8 run. 
+! Lines not beginning with a letter or digit are comments.
+
+! 1) Settings used in the main program.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:timesAllowErrors = 5          ! allow a few failures before quitting
+
+! 2) Settings related to output in init(), next() and stat().
+Init:showChangedSettings = on      ! list changed settings
+Init:showChangedParticleData = on  ! list changed particle data
+Next:numberCount = 100             ! print message every n events
+Next:numberShowInfo = 1            ! print event information n times
+Next:numberShowProcess = 1         ! print process record n times
+Next:numberShowEvent = 1           ! print event record n times
+
+! 3) Beam parameter settings. Incoming beams do not radiate.
+Beams:idA = -11                    ! ficititious incoming e+ 
+Beams:idB = 11                     ! ficititious incoming e-
+PDF:lepton = off                   ! no radiation off ficititious e+e-
+Beams:eCM = 500.                   ! CM energy of collision
+
+! 4) Set up properties of the GeneralResonance and its decay channels.
+! id:all = name antiName spinType chargeType colType m0 mWidth mMin mMax tau0
+999999:all = GeneralResonance void 1 0 0 500. 1. 0. 0. 0.
+! id:addChannel = onMode bRatio meMode product1 product2 ...
+! Note: sum of branching ratios automatically rescaled to 1.
+! Current channels illustrative only; insert your own decay list.
+999999:addChannel = 1 0.2 101 1 -1   !  -> d dbar 
+999999:addChannel = 1 0.2 101 6 -6   !  -> t tbar
+999999:addChannel = 1 0.2 101 15 -15 !  -> tau- tau+
+999999:addChannel = 1 0.2 101 24 -24 !  -> W+ W-
+999999:addChannel = 1 0.2 101 25 25  !  -> h0 h0
+
+! 5) Tell that also long-lived should decay.
+13:mayDecay   = true                 ! mu+-
+211:mayDecay  = true                 ! pi+-
+321:mayDecay  = true                 ! K+-
+130:mayDecay  = true                 ! K0_L
+2112:mayDecay = true                 ! n 
diff --git a/PYTHIA8/pythia8170/examples/main08.cc b/PYTHIA8/pythia8170/examples/main08.cc
new file mode 100644 (file)
index 0000000..9b87bdd
--- /dev/null
@@ -0,0 +1,189 @@
+// main08.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates methods to emphasize generation at high pT.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Different modes are illustrated for setting the pT ranges.
+  // 1 : Hardcoded in the main program.
+  // 2 : Using the Main:subrun keyword in a separate command file.
+  // A third method instead biases selection continuously.
+  // 3 : Bias high-pT selection by a pT^4 factor.
+  // Matching also to low-pT processes is more complicated.
+  // 4 : Matching between low- and high-pT. (No diffraction.)
+  // 5: As 4, but bias high-pT selection by a pT^4 factor.
+  int mode = 5;
+
+  // Number of events to generate per bin.
+  int nEvent = 100000;
+
+  // One does not need complete events to study pThard spectrum only.
+  bool completeEvents = false;
+
+  // Optionally minimize output (almost) to final results.
+  bool smallOutput = true;
+
+  // Book histograms.
+  int nRange = 100;
+  double pTrange = (mode < 4) ? 1000. : 100.;
+  Hist pTraw("pTHat distribution, unweighted", nRange, 0., pTrange);
+  Hist pTnorm("pTHat distribution, weighted", nRange, 0., pTrange);
+  Hist pTpow3("pTHat distribution, pT3*weighted", nRange, 0., pTrange);
+  Hist pTpow5("pTHat distribution, pT5*weighted", nRange, 0., pTrange);
+  Hist pTnormPart("pTHat distribution, weighted", nRange, 0., pTrange);
+  Hist pTpow3Part("pTHat distribution, pT3*weighted", nRange, 0., pTrange);
+  Hist pTpow5Part("pTHat distribution, pT5*weighted", nRange, 0., pTrange);
+
+  // Generator.
+  Pythia pythia;
+
+  // Shorthand for some public members of pythia (also static ones).
+  Settings& settings = pythia.settings;
+  Info& info = pythia.info;
+
+  // Optionally limit output to minimal one.
+  if (smallOutput) {
+    pythia.readString("Init:showProcesses = off");  
+    pythia.readString("Init:showMultipartonInteractions = off");  
+    pythia.readString("Init:showChangedSettings = off");  
+    pythia.readString("Init:showChangedParticleData = off");  
+    pythia.readString("Next:numberCount = 1000000000");  
+    pythia.readString("Next:numberShowInfo = 0");  
+    pythia.readString("Next:numberShowProcess = 0");  
+    pythia.readString("Next:numberShowEvent = 0");  
+  }
+
+  // Number of bins to use. In mode 2 read from main08.cmnd file.
+  int nBin = 5;
+  if (mode == 2) {
+    pythia.readFile("main08.cmnd"); 
+    nBin = pythia.mode("Main:numberOfSubruns");
+  } 
+  else if (mode == 3) nBin = 1; 
+  else if (mode == 4) nBin = 4; 
+  else if (mode == 5) nBin = 2; 
+
+  // Mode 1: set up five pT bins - last one open-ended.
+  double pTlimit[6] = {100., 150., 250., 400., 600., 0.};
+
+  // Modes 4 & 5: set up pT bins for range [0, 100]. The lowest bin
+  // is generated with soft processes, to regularize pT -> 0 blowup. 
+  // Warning: if pTlimitLow[1] is picked too low there will be a 
+  // visible discontinuity, since soft processes are generated with 
+  // dampening and "Sudakov" for pT -> 0, while hard processes are not.
+  double pTlimitLow[6] = {0., 20., 40., 70., 100.};
+  double pTlimitTwo[3] = {0., 20., 100.};
+
+  // Loop over number of bins, i.e. number of subruns.
+  for (int iBin = 0; iBin < nBin; ++iBin) {
+
+    // Normally HardQCD, but in two cases minBias.
+    // Need MPI on in minBias to get first interaction, but not else.
+    if (mode > 3 && iBin == 0) {
+      pythia.readString("HardQCD:all = off");  
+      pythia.readString("SoftQCD:minBias = on"); 
+      if (!completeEvents) { 
+      pythia.readString("PartonLevel:all = on"); 
+        pythia.readString("PartonLevel:ISR = off");  
+        pythia.readString("PartonLevel:FSR = off");  
+        pythia.readString("HadronLevel:all = off");
+      }  
+    } else { 
+      pythia.readString("HardQCD:all = on");  
+      pythia.readString("SoftQCD:minBias = off");  
+      if (!completeEvents) pythia.readString("PartonLevel:all = off");  
+    } 
+
+    // Mode 1: hardcoded here. Use settings.parm for non-string input.  
+    if (mode == 1) { 
+      settings.parm("PhaseSpace:pTHatMin", pTlimit[iBin]);  
+      settings.parm("PhaseSpace:pTHatMax", pTlimit[iBin + 1]);
+    }
+
+    // Mode 2: subruns stored in the main08.cmnd file.
+    else if (mode == 2) pythia.readFile("main08.cmnd", iBin);  
+
+    // Mode 3: The whole range in one step, but pT-weighted.
+    else if (mode == 3) {
+      settings.parm("PhaseSpace:pTHatMin", pTlimit[0]);  
+      settings.parm("PhaseSpace:pTHatMax", 0.);
+      pythia.readString("PhaseSpace:bias2Selection = on");  
+      pythia.readString("PhaseSpace:bias2SelectionPow = 4.");  
+      pythia.readString("PhaseSpace:bias2SelectionRef = 100.");  
+    }
+
+    // Mode 4: hardcoded here. Use settings.parm for non-string input.  
+    else if (mode == 4) { 
+      settings.parm("PhaseSpace:pTHatMin", pTlimitLow[iBin]);  
+      settings.parm("PhaseSpace:pTHatMax", pTlimitLow[iBin + 1]);
+    }
+
+    // Mode 5: hardcoded here. Use settings.parm for non-string input. 
+    // Hard processes in one step, but pT-weighted.
+    else if (mode == 5) { 
+      settings.parm("PhaseSpace:pTHatMin", pTlimitTwo[iBin]);  
+      settings.parm("PhaseSpace:pTHatMax", pTlimitTwo[iBin + 1]);
+      if (iBin == 1) {
+        pythia.readString("PhaseSpace:bias2Selection = on");  
+        pythia.readString("PhaseSpace:bias2SelectionPow = 4.");  
+        pythia.readString("PhaseSpace:bias2SelectionRef = 20.");  
+      }
+    }
+
+    // Initialize for LHC at 14 TeV.
+    pythia.readString("Beams:eCM = 14000.");  
+    pythia.init();
+
+    // Reset local histograms (that need to be rescaled before added).
+    pTnormPart.null();
+    pTpow3Part.null();
+    pTpow5Part.null();
+
+    // Begin event loop.
+    for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+      // Generate events. Quit if failure.
+      if (!pythia.next()) break;
+
+      // Soft events have no upper pT limit. They therefore overlap
+      // with hard events, and the overlap must be removed by hand.
+      // No overlap for elastic/diffraction, which is only part of soft.
+      double pTHat  = info.pTHat();
+      if (mode > 3 && iBin == 0 && info.isMinBias() 
+        && pTHat > pTlimitLow[1]) continue;
+
+      // Fill hard scale of event.
+      double weight = info.weight();
+      pTraw.fill( pTHat );
+      pTnormPart.fill( pTHat, weight);
+      pTpow3Part.fill( pTHat, weight * pow3(pTHat) );
+      pTpow5Part.fill( pTHat, weight * pow5(pTHat) );
+
+    // End of event loop. Statistics.
+    }
+    if (!smallOutput) pythia.stat();
+
+    // Normalize to cross section for each case, and add to sum.
+    double sigmaNorm = (info.sigmaGen() / info.weightSum()) 
+                     * (nRange / pTrange);
+    pTnorm += sigmaNorm * pTnormPart;
+    pTpow3 += sigmaNorm * pTpow3Part;
+    pTpow5 += sigmaNorm * pTpow5Part;
+
+  // End of pT-bin loop.
+  }
+
+  // Output histograms.
+  cout << pTraw << pTnorm << pTpow3 << pTpow5;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main08.cmnd b/PYTHIA8/pythia8170/examples/main08.cmnd
new file mode 100644 (file)
index 0000000..3a7cba3
--- /dev/null
@@ -0,0 +1,29 @@
+! File: main08.cmnd
+! This file contains commands to be read in for a Pythia8 run. 
+! Lines not beginning with a letter or digit are comments.
+! Names are case-insensitive  -  but spellings-sensitive!
+! The changes here are illustrative, not always physics-motivated.
+
+! The current file is input for subruns with consecutive pT ranges.
+
+Main:numberOfSubruns = 5
+
+Main:subrun = 0
+PhaseSpace:pTHatMin = 100.
+PhaseSpace:pTHatMax = 150.
+
+Main:subrun = 1 
+PhaseSpace:pTHatMin = 150. 
+PhaseSpace:pTHatMax = 250.
+
+Main:subrun = 2 
+PhaseSpace:pTHatMin = 250.
+PhaseSpace:pTHatMax = 400.
+
+Main:subrun = 3 
+PhaseSpace:pTHatMin = 400. 
+PhaseSpace:pTHatMax = 600.
+
+Main:subrun = 4 
+PhaseSpace:pTHatMin = 600.
+PhaseSpace:pTHatMax = 0.              ! 0. means open-ended
diff --git a/PYTHIA8/pythia8170/examples/main09.cc b/PYTHIA8/pythia8170/examples/main09.cc
new file mode 100644 (file)
index 0000000..c0a6349
--- /dev/null
@@ -0,0 +1,84 @@
+// main09.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Generate a predetermined second hard interaction.
+
+#include "Pythia.h"
+
+using namespace Pythia8;
+int main() {
+
+  // Generator. 
+  Pythia pythia;
+  Event& event   = pythia.event;
+
+  // Select first hard process (just a small sample of possibilities).
+  //pythia.readString("HardQCD:all = on");
+  pythia.readString("Top:all = on");
+  //pythia.readString("WeakSingleBoson:ffbar2gmZ = on");
+  //pythia.readString("WeakSingleBoson:ffbar2W = on");
+
+  // Select second hard process (complete list of options).
+  pythia.readString("SecondHard:generate = on");
+  //pythia.readString("SecondHard:TwoJets = on");
+  pythia.readString("SecondHard:PhotonAndJet = on");
+  //pythia.readString("SecondHard:TwoPhotons = on");
+  //pythia.readString("SecondHard:SingleGmZ = on");
+  //pythia.readString("SecondHard:SingleW = on");
+  //pythia.readString("SecondHard:TwoBJets = on");
+  
+  // Kinematics cuts, common for the two. 
+  pythia.readString("PhaseSpace:mHatMin = 40.");
+  pythia.readString("PhaseSpace:pTHatMin = 20.");
+
+  // Initialize for LHC at 8 TeV.
+  pythia.readString("Beams:eCM = 8000.");  
+  pythia.init();
+
+  // Histogram.
+  Hist pTfirst("pT first collision",    100, 0., 400.);
+  Hist pTsecond("pT second collision",  100, 0., 200.);
+  Hist pTdiff("pT first-second collision", 100, -100., 300.);
+  Hist nMult("number of multiparton interactions", 100, -0.5, 99.5);
+  Hist bMore("b enhancement factor",    100, 0., 10.);
+  Hist nChg("charged multiplicity", 100, -0.5, 999.5);
+
+  // Generate events.
+  for (int iev = 0; iev < 1000; ++iev) {
+    pythia.next();
+
+    // Histogram pT.
+    double pT1 = pythia.info.pTMPI(0);
+    double pT2 = pythia.info.pTMPI(1);
+    pTfirst.fill( pT1 );
+    pTsecond.fill( pT2 );
+    pTdiff.fill( pT1 - pT2 );
+
+    // Histogram multiparton interactions
+    double nMPI = pythia.info.nMPI();
+    nMult.fill( nMPI );
+    bMore.fill( pythia.info.enhanceMPI() );
+
+    // Histogram charged multiplicity.
+    int nCharged = 0;
+    for (int i = 0; i < event.size(); ++i) 
+      if (event[i].isFinal() && event[i].isCharged()) ++nCharged; 
+    nChg.fill( nCharged );
+
+  }
+
+  // Compare full statistics listing with what is set in info.
+  pythia.stat();
+  cout << scientific << setprecision(3) << "\n From pythia.info: sigma = " 
+       << pythia.info.sigmaGen() << " +- " << pythia.info.sigmaErr()
+       << endl;
+
+  // Print histograms.
+  cout << pTfirst << pTsecond << pTdiff << nMult << bMore << nChg;
+
+  // Done. 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main10.cc b/PYTHIA8/pythia8170/examples/main10.cc
new file mode 100644 (file)
index 0000000..93b29a5
--- /dev/null
@@ -0,0 +1,159 @@
+// main10.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Example how you can use UserHooks to trace pT spectrum through program,
+// and veto undesirable jet multiplicities. 
+
+#include "Pythia.h"
+using namespace Pythia8; 
+
+//==========================================================================
+
+// Put histograms here to make them global, so they can be used both 
+// in MyUserHooks and in the main program.
+
+Hist pTtrial("trial pT spectrum", 100, 0., 400.);
+Hist pTselect("selected pT spectrum (before veto)", 100, 0., 400.);
+Hist pTaccept("accepted pT spectrum (after veto)", 100, 0., 400.);
+Hist nPartonsB("number of partons before veto", 20, -0.5, 19.5);
+Hist nJets("number of jets before veto", 20, -0.5, 19.5);
+Hist nPartonsA("number of partons after veto", 20, -0.5, 19.5);
+Hist nFSRatISR("number of FSR emissions at first ISR emission", 
+  20, -0.5, 19.5);
+
+//==========================================================================
+
+// Write own derived UserHooks class.
+
+class MyUserHooks : public UserHooks {
+
+public:
+
+  // Constructor creates anti-kT jet finder with (-1, R, pTmin, etaMax).
+  MyUserHooks() { slowJet = new SlowJet(-1, 0.7, 10., 5.); }
+
+  // Destructor deletes anti-kT jet finder.
+  ~MyUserHooks() {delete slowJet;}
+
+  // Allow process cross section to be modified...
+  virtual bool canModifySigma() {return true;}
+  
+  // ...which gives access to the event at the trial level, before selection.
+  virtual double multiplySigmaBy(const SigmaProcess* sigmaProcessPtr,
+    const PhaseSpace* phaseSpacePtr, bool inEvent) {
+
+    // All events should be 2 -> 2, but kill them if not.
+    if (sigmaProcessPtr->nFinal() != 2) return 0.; 
+        
+    // Extract the pT for 2 -> 2 processes in the event generation chain
+    // (inEvent = false for initialization).
+    if (inEvent) { 
+      pTHat = phaseSpacePtr->pTHat();
+      // Fill histogram of pT spectrum.
+      pTtrial.fill( pTHat );
+    }
+    
+    // Here we do not modify 2 -> 2 cross sections.
+    return 1.;    
+  }
+
+  // Allow a veto for the interleaved evolution in pT.
+  virtual bool canVetoPT() {return true;}  
+
+  // Do the veto test at a pT scale of 5 GeV.
+  virtual double scaleVetoPT() {return 5.;} 
+
+  // Access the event in the interleaved evolution.
+  virtual bool doVetoPT(int iPos, const Event& event) {
+
+    // iPos <= 3 for interleaved evolution; skip others.
+    if (iPos > 3) return false;
+
+    // Fill histogram of pT spectrum at this stage.
+    pTselect.fill(pTHat);
+
+    // Extract a copy of the partons in the hardest system.
+    subEvent(event);
+    nPartonsB.fill( workEvent.size() );
+
+    // Find number of jets with given conditions.
+    slowJet->analyze(event);
+    int nJet = slowJet->sizeJet();      
+    nJets.fill( nJet );
+
+    // Veto events which do not have exactly three jets.
+    if (nJet != 3) return true;
+
+    // Statistics of survivors.
+    nPartonsA.fill( workEvent.size() );
+    pTaccept.fill(pTHat);
+
+    // Do not veto events that got this far.
+    return false;
+
+  }
+
+  // Allow a veto after (by default) first step.
+  virtual bool canVetoStep() {return true;}
+
+  // Access the event in the interleaved evolution after first step.
+  virtual bool doVetoStep( int iPos, int nISR, int nFSR, const Event& ) {
+
+    // Only want to study what happens at first ISR emission
+    if (iPos == 2 && nISR == 1) nFSRatISR.fill( nFSR );
+
+    // Not intending to veto any events here.
+    return false;
+  } 
+
+private:
+
+  // The anti-kT (or kT, C/A) jet finder.
+  SlowJet* slowJet;
+
+  // Save the pThat scale.
+  double pTHat;
+
+};
+
+//==========================================================================
+
+int main() {
+
+  // Generator.
+  Pythia pythia;
+
+  //  Process selection. No need to study hadron level.
+  pythia.readString("HardQCD:all = on");  
+  pythia.readString("PhaseSpace:pTHatMin = 50.");  
+  pythia.readString("HadronLevel:all = off");  
+
+  // Set up to do a user veto and send it in.
+  MyUserHooks* myUserHooks = new MyUserHooks();
+  pythia.setUserHooksPtr( myUserHooks);
+  // Tevatron initialization. 
+  pythia.readString("Beams:idB = -2212"); 
+  pythia.readString("Beams:eCM = 1960.");
+  pythia.init();
+   
+  // Begin event loop.
+  for (int iEvent = 0; iEvent < 1000; ++iEvent) {
+
+    // Generate events. 
+    pythia.next();
+
+  // End of event loop.
+  }
+
+  // Statistics. Histograms.
+  pythia.stat();
+  cout << pTtrial << pTselect << pTaccept 
+       << nPartonsB << nJets << nPartonsA 
+       << nFSRatISR;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main11.cc b/PYTHIA8/pythia8170/examples/main11.cc
new file mode 100644 (file)
index 0000000..f1cf48d
--- /dev/null
@@ -0,0 +1,60 @@
+// main11.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates how Les Houches Event File input can be used in Pythia8.
+// It uses the ttsample.lhe input file, the latter only with 100 events.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+
+  // Generator. We here stick with default values, but changes
+  // could be inserted with readString or readFile.          
+  Pythia pythia;                            
+
+  // Initialize Les Houches Event File run. List initialization information.
+  pythia.readString("Beams:frameType = 4"); 
+  pythia.readString("Beams:LHEF = ttbar.lhe"); 
+  pythia.init();      
+
+  // Book histogram.
+  Hist nCharged("charged particle multiplicity",100,-0.5,399.5); 
+
+  // Allow for possibility of a few faulty events.
+  int nAbort = 10;
+  int iAbort = 0;
+
+  // Begin event loop; generate until none left in input file.     
+  for (int iEvent = 0; ; ++iEvent) {
+
+    // Generate events, and check whether generation failed.
+    if (!pythia.next()) {
+
+      // If failure because reached end of file then exit event loop.
+      if (pythia.info.atEndOfFile()) break; 
+
+      // First few failures write off as "acceptable" errors, then quit.
+      if (++iAbort < nAbort) continue;
+      break;
+    }
+
+    // Sum up final charged multiplicity and fill in histogram.
+    int nChg = 0;                 
+    for (int i = 0; i < pythia.event.size(); ++i) 
+    if (pythia.event[i].isFinal() && pythia.event[i].isCharged()) 
+      ++nChg;
+    nCharged.fill(nChg);               
+
+  // End of event loop.        
+  }                                           
+
+  // Give statistics. Print histogram.
+  pythia.stat();
+  cout << nCharged;  
+
+  // Done.                           
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main12.cc b/PYTHIA8/pythia8170/examples/main12.cc
new file mode 100644 (file)
index 0000000..b749d17
--- /dev/null
@@ -0,0 +1,111 @@
+// main12.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates how Les Houches Event File input can be used in PYTHIA.
+// It uses two LHE files, ttbar.lhe and ttbar2.lhe, which are combined
+// using Beams:newLHEFsameInit = on to skip new initialization second time.
+// Then the second file is viewed as a simple continuation of the first,
+// just split for practical reasons, rather than as a separate new run 
+// with a new set of processes.
+// In the first file top decays have been performed, in the second not,
+// and are instead handled by the internal PYTHIA resonance-decay machinery. 
+// Furthermore the internal top production processes are switched on and
+// mixed in, giving an unrealistic "double up" total top cross section.
+// Much of this of course is not intended to be realistic, 
+// but rather illustrates several tricks that can be useful.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+
+  //  Number of listed events. Allow for possibility of a few faulty events.
+  int nPrintLHA  = 1;             
+  int nPrintRest = 0;             
+  int nAbort     = 10;
+
+  // Generator           
+  Pythia pythia;                            
+
+  // Switch on internal ttbar production.
+  pythia.readString("Top:gg2ttbar = on");  
+  pythia.readString("Top:qqbar2ttbar = on"); 
+
+  // Use same top mass as in Pythia 6.4 to simplify comparison.
+  pythia.readString("6:m0 = 175.");    
+
+  // No automatic event listings - do it manually below.
+  pythia.readString("Next:numberShowLHA = 0"); 
+  pythia.readString("Next:numberShowInfo = 0"); 
+  pythia.readString("Next:numberShowProcess = 0"); 
+  pythia.readString("Next:numberShowEvent = 0"); 
+
+  // Initialize Les Houches Event File run.
+  pythia.readString("Beams:frameType = 4"); 
+  pythia.readString("Beams:LHEF = ttbar.lhe");   
+  pythia.init();   
+
+  // Book histogram.
+  Hist nCharged("charged particle multiplicity",100,-0.5,399.5); 
+
+  // Set counters.
+  int iPrintLHA  = 0;             
+  int iPrintRest = 0;             
+  int iAbort     = 0;
+  int iFile      = 1;
+
+  // Begin event loop   
+  for (int iEvent = 0; ; ++iEvent) {
+
+    // Generate until none left in input file.  
+    if (!pythia.next()) {
+      if (pythia.info.atEndOfFile()) {
+
+        // First time open next file, second time stop event loop.
+        if (iFile == 1) {
+          pythia.readString("Beams:newLHEFsameInit = on"); 
+          pythia.readString("Beams:LHEF = ttbar2.lhe");   
+          pythia.init();   
+          ++iFile;
+          continue;
+       } else break;          
+      }
+
+      // First few failures write off as "acceptable" errors, then quit.
+      if (++iAbort < nAbort) continue;
+      break;
+    }
+  
+    // List first few Les Houches and other events.
+    if (pythia.info.isLHA() && iPrintLHA < nPrintLHA) {     
+      pythia.LHAeventList();               
+      pythia.info.list();          
+      pythia.process.list();          
+      pythia.event.list();  
+      ++iPrintLHA;         
+    } else if (!pythia.info.isLHA() && iPrintRest < nPrintRest) {     
+      pythia.info.list();          
+      pythia.process.list();          
+      pythia.event.list();           
+      ++iPrintRest;         
+    }                 
+
+    // Sum up final charged multiplicity and fill in histogram.
+    int nChg = 0;                 
+    for (int i = 0; i < pythia.event.size(); ++i) 
+    if (pythia.event[i].isFinal() && pythia.event[i].isCharged()) 
+      ++nChg;
+    nCharged.fill(nChg);               
+
+  // End of event loop.        
+  }                                           
+
+  // Give statistics. Print histogram.
+  pythia.stat();
+  cout << nCharged;  
+
+  // Done.                           
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main13.cc b/PYTHIA8/pythia8170/examples/main13.cc
new file mode 100644 (file)
index 0000000..a65e4ac
--- /dev/null
@@ -0,0 +1,70 @@
+// main13.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 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 is a simple test program. 
+// It illustrates how two Les Houches Event Files can be combined in PYTHIA,
+// just like in main12.cc, but here with the difference that information is
+// stored in main13.cmnd and read out using the subruns possibility.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+
+  // Book histogram.
+  Hist nCharged("charged particle multiplicity",100,-0.5,399.5); 
+
+  // Generator.           
+  Pythia pythia;  
+
+  // Read in subrun-independent data from main13.cmnd.
+  pythia.readFile( "main13.cmnd", 0); 
+                          
+  // Extract data to be used in main program. Set counters.
+  int nSubrun = pythia.mode("Main:numberOfSubruns"); 
+  int nAbort  = pythia.mode("Main:timesAllowErrors");
+  int iAbort  = 0;
+
+  // Begin loop over subruns.
+  for (int iSubrun = 1; iSubrun <= nSubrun; ++iSubrun) {
+
+    // Read in subrun-specific data from main13.cmnd.
+    pythia.readFile( "main13.cmnd", iSubrun); 
+
+    // Initialize generator.
+    pythia.init();   
+
+    // Begin infinite event loop - to be exited at end of file.
+    for (int iEvent = 0; ; ++iEvent) {
+
+      // Generate next event.  
+      if (!pythia.next()) {
+
+        // Leave event loop if at end of file.
+        if (pythia.info.atEndOfFile()) break;
+
+        // First few failures write off as "acceptable" errors, then quit.
+        if (++iAbort < nAbort) continue;
+        break;
+      }
+
+      // Sum up final charged multiplicity and fill in histogram.
+      int nChg = 0;                 
+      for (int i = 0; i < pythia.event.size(); ++i) 
+      if (pythia.event[i].isFinal() && pythia.event[i].isCharged()) ++nChg;
+      nCharged.fill(nChg);               
+
+    // End of event loop.        
+    } 
+
+  // End of subrun loop.
+  }                                          
+
+  // Give statistics. Print histogram.
+  pythia.stat();
+  cout << nCharged;  
+
+  // Done.                           
+  return 0;
+}
diff --git a/PYTHIA8/pythia8170/examples/main13.cmnd b/PYTHIA8/pythia8170/examples/main13.cmnd
new file mode 100644 (file)
index 0000000..64906f5
--- /dev/null
@@ -0,0 +1,33 @@
+! main13.cmnd.
+! This file contains commands to be read in for a Pythia8 run. 
+! Lines not beginning with a letter or digit are comments.
+! Names are case-insensitive  -  but spellings-sensitive!
+! The settings here are illustrative, not always physics-motivated.
+
+! 1) Settings used in the main program.
+Main:timesAllowErrors = 3          ! how many aborts before run stops
+
+! 2) Settings related to output in init(), next() and stat().
+Init:showChangedSettings = on      ! list changed settings
+Init:showChangedParticleData = off ! list changed particle data
+Next:numberCount =   0             ! print message every n events, 0 = off
+Next:numberShowLHA = 1             ! print LHA information n times
+Next:numberShowInfo = 1            ! print event information n times
+Next:numberShowProcess = 1         ! print process record n times
+Next:numberShowEvent = 0           ! print event record n times
+
+! 3) Other common settings.
+6:m0 = 175.                        ! same m_t as Pythia 6.4 to compare
+
+! 4) The number of subruns to execute.
+Main:numberOfSubruns = 2
+
+! 5) Information specific to the first subrun
+Main:subrun = 1                    ! matches readFile( ..., 1)
+Beams:frameType = 4                ! use LHEF input
+Beams:LHEF = ttbar.lhe             ! first LHEF event file
+
+! 6) Information specific to the second subrun
+Main:subrun = 2                    ! matches readFile( ..., 2)
+Beams:newLHEFsameInit = on         ! no reinitialization needed/wanted
+Beams:LHEF = ttbar2.lhe            ! second LHEF event file
diff --git a/PYTHIA8/pythia8170/examples/main14.cc b/PYTHIA8/pythia8170/examples/main14.cc
new file mode 100644 (file)
index 0000000..0b4b9b0
--- /dev/null
@@ -0,0 +1,177 @@
+// main14.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2012 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Comparison with some PYTHIA 6.413 cross sections process by process.
+// Several processes have been left out to keep reasonable execution time.
+// Some processes are not handled absolutely identically, so minor
+// systematic differences may occur in addition to the statistical ones.
+// (For some MSSM Higgs processes 6.413 has been modified to use
+// running quark masses in loops, like 8.1, to allow proper comparison.)
+// Subruns  0 -  5 : QCD jets
+//          6 - 10 : prompt photons.
+//         11 - 12 : t-channel gamma/Z/W exchange.
+//         13 - 23 : gamma*/Z^0/W^+-, singly, in pairs or with parton
+//         24 - 25 : onia.
+//         26 - 30 : top.
+//         31 - 40 : Standard Model Higgs.
+//         41 - 45 : MSSM Higgses (trivial couplings).
+//         46 - 47 : Z' and W' 
+//         48 - 51 : Left-right-symmetric scenario.
+//         52 - 52 : Leptoquark.
+//         53 - 55 : Excited fermions (compositeness).
+//         56 - 56 : excited Graviton (RS extra dimensions).
+
+#include "Pythia.h"
+
+using namespace Pythia8;
+int main() {
+
+  // First and last process to test:&n