New pythia8 version
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 19 Nov 2010 08:37:18 +0000 (08:37 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 19 Nov 2010 08:37:18 +0000 (08:37 +0000)
473 files changed:
PYTHIA8/pythia8145/AUTHORS [new file with mode: 0644]
PYTHIA8/pythia8145/COPYING [new file with mode: 0644]
PYTHIA8/pythia8145/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8145/Makefile [new file with mode: 0644]
PYTHIA8/pythia8145/Makefile.msc [new file with mode: 0644]
PYTHIA8/pythia8145/README [new file with mode: 0644]
PYTHIA8/pythia8145/README.HepMC [new file with mode: 0644]
PYTHIA8/pythia8145/README.Win32 [new file with mode: 0644]
PYTHIA8/pythia8145/configure [new file with mode: 0755]
PYTHIA8/pythia8145/examples/Makefile [new file with mode: 0644]
PYTHIA8/pythia8145/examples/README [new file with mode: 0644]
PYTHIA8/pythia8145/examples/configure [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main01.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main02.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main03.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main03.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main04.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main04.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main05.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main06.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main06.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main07.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main07.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main08.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main08.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main09.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main10.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main11.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main12.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main13.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main14.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main15.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main16.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main16.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main17.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main17.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main18.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main19.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main20.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main21.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main22.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main22.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main23.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main24.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main25.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main26.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main27.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main28.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main29.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main29.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main30.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main31.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main32.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main32.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main41.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main42.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main43.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main43.cmnd [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main44.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main51.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main61.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main71.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main72.cc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/main72.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out01 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out02 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out03 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out04 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out05 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out06 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out07 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out08 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out09 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out10 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out11 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out12 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out13 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out14 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out15 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out16 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out17 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out18 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out19 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out20 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out21 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out22 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out23 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out24 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out25 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out26 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out27 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out28 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out29 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out30 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out71 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/outref/out72 [new file with mode: 0644]
PYTHIA8/pythia8145/examples/photoninproton.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/examples/powheg-hvq.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/examples/runmains [new file with mode: 0755]
PYTHIA8/pythia8145/examples/softsusy.spc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/sps1a.spc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/sps1aWithDecays.spc [new file with mode: 0644]
PYTHIA8/pythia8145/examples/ttbar.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/examples/ttbar2.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/examples/weakbosons.lhe [new file with mode: 0644]
PYTHIA8/pythia8145/hepmcinterface/HepMCInterface.cc [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ASecondHardProcess.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/AccessPYTHIA6Processes.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/AdvancedUsage.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/BeamParameters.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/BeamRemnants.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/BeamShape.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Bibliography.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/BoseEinsteinEffects.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/COPYING [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/CompositenessProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/CouplingsAndScales.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Diffraction.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ElectroweakProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ErrorChecks.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/EventAnalysis.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/EventInformation.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/EventRecord.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/EventStatistics.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ExternalDecays.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ExtraDimensionalProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/FlavourSelection.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/FourVectors.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/FourthGenerationProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Fragmentation.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Frontpage.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Glossary.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/HadronLevelStandalone.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/HepMCInterface.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/HiddenValleyProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/HiggsProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Histograms.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ImplementNewShowers.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Index.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/JetFinders.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/LeftRightSymmetryProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/LeptoquarkProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/LesHouchesAccord.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/MainProgramSettings.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/MasterSwitches.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/MultipleInteractions.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/NewGaugeBosonProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/OniaProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/PDFSelection.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/PYTHIA6TranslationTable.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ParticleData.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ParticleDataScheme.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ParticleDecays.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ParticleProperties.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/PartonDistributions.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/PhaseSpaceCuts.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ProcessSelection.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ProgramClasses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ProgramFiles.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ProgramFlow.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ProgramMethods.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/QCDProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ROOTusage.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/RandomNumberSeed.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/RandomNumbers.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/ResonanceDecays.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SUSYLesHouchesAccord.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SUSYProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SampleMainPrograms.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SaveSettings.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SemiInternalProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SemiInternalResonances.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SettingsScheme.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/SpacelikeShowers.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/StandardModelParameters.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/TimelikeShowers.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/TopProcesses.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/TotalCrossSections.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Tunes.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/UpdateHistory.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/UserHooks.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Version.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/Welcome.html [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/pythia.css [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/pythia32.gif [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/pythia8100.pdf [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/pythia99.gif [new file with mode: 0644]
PYTHIA8/pythia8145/htmldoc/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8145/include/Analysis.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/Basics.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/BeamParticle.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/BeamRemnants.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/BeamShape.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/BoseEinstein.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/Event.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/FragmentationFlavZpT.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/FragmentationSystems.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/HadronLevel.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/HepMCInterface.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/Info.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/LHAFortran.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/LHAPDFInterface.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/LesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/MiniStringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/MultipleInteractions.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ParticleData.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ParticleDecays.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PartonDistributions.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PartonLevel.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PartonSystems.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PhaseSpace.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ProcessContainer.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ProcessLevel.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/Pythia.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PythiaComplex.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/PythiaStdlib.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ResonanceDecays.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/ResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/Settings.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaCompositeness.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaEW.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaExtraDim.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaGeneric.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaHiggs.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaLeftRightSym.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaLeptoquark.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaNewGaugeBosons.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaOnia.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaProcess.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaQCD.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaSUSY.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SigmaTotal.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SpaceShower.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/StandardModel.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/StringFragmentation.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SusyCouplings.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SusyLesHouches.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/SusyResonanceWidths.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/TimeShower.h [new file with mode: 0644]
PYTHIA8/pythia8145/include/UserHooks.h [new file with mode: 0644]
PYTHIA8/pythia8145/lhapdfdummy/LHAPDFDummy.cc [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ASecondHardProcess.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/AccessPYTHIA6Processes.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/AdvancedUsage.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/BeamParameters.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/BeamRemnants.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/BeamShape.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Bibliography.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/BoseEinsteinEffects.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/COPYING [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/CompositenessProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/CouplingsAndScales.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Diffraction.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ElectroweakProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ErrorChecks.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/EventAnalysis.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/EventInformation.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/EventRecord.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/EventStatistics.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ExternalDecays.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ExtraDimensionalProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/FlavourSelection.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/FourVectors.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/FourthGenerationProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Fragmentation.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Frontpage.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/GUIDELINES [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Glossary.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/HadronLevelStandalone.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/HepMCInterface.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/HiddenValleyProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/HiggsProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Histograms.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ImplementNewShowers.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Index.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/JetFinders.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/LeftRightSymmetryProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/LeptoquarkProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/LesHouchesAccord.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/MainProgramSettings.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/MasterSwitches.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/MultipleInteractions.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/NewGaugeBosonProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/OniaProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/PDFSelection.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/PYTHIA6TranslationTable.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ParticleData.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ParticleDataScheme.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ParticleDecays.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ParticleProperties.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/PartonDistributions.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/PhaseSpaceCuts.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ProcessSelection.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ProgramClasses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ProgramFiles.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ProgramFlow.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ProgramMethods.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/QCDProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ROOTusage.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/RandomNumberSeed.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/RandomNumbers.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/ResonanceDecays.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SUSYLesHouchesAccord.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SUSYProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SampleMainPrograms.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SaveSettings.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SemiInternalProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SemiInternalResonances.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SettingsScheme.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/SpacelikeShowers.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/StandardModelParameters.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/TimelikeShowers.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/TopProcesses.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/TotalCrossSections.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Tunes.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/UpdateHistory.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/UserHooks.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Version.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/Welcome.php [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/php.txt [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/pythia.css [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/pythia32.gif [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/pythia8100.pdf [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/pythia99.gif [new file with mode: 0644]
PYTHIA8/pythia8145/phpdoc/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8145/rootexample/README [new file with mode: 0644]
PYTHIA8/pythia8145/rootexample/ex1.C [new file with mode: 0644]
PYTHIA8/pythia8145/rootexample/goex1 [new file with mode: 0755]
PYTHIA8/pythia8145/rootexample/pythiaLinkdef.h [new file with mode: 0644]
PYTHIA8/pythia8145/rootexample/pythiaROOT.h [new file with mode: 0644]
PYTHIA8/pythia8145/src/Analysis.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/Basics.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/BeamParticle.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/BeamRemnants.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/BeamShape.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/BoseEinstein.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/Event.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/FragmentationFlavZpT.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/FragmentationSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/HadronLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/Info.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/LesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/MiniStringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/MultipleInteractions.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ParticleData.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ParticleDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/PartonDistributions.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/PartonLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/PartonSystems.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/PhaseSpace.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ProcessContainer.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ProcessLevel.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/Pythia.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/PythiaStdlib.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ResonanceDecays.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/ResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/Settings.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaCompositeness.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaEW.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaExtraDim.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaGeneric.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaHiggs.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaLeftRightSym.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaLeptoquark.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaNewGaugeBosons.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaOnia.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaProcess.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaQCD.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaSUSY.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SigmaTotal.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SpaceShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/StandardModel.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/StringFragmentation.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SusyCouplings.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SusyLesHouches.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/SusyResonanceWidths.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/TimeShower.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/src/UserHooks.cxx [new file with mode: 0644]
PYTHIA8/pythia8145/worksheet.pdf [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc.tgz [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ASecondHardProcess.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/AccessPYTHIA6Processes.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/AdvancedUsage.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/BeamParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/BeamRemnants.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/BeamShape.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Bibliography.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/BoseEinsteinEffects.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/CompositenessProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/CouplingsAndScales.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Diffraction.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ElectroweakProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ErrorChecks.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/EventAnalysis.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/EventInformation.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/EventRecord.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/EventStatistics.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ExternalDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ExtraDimensionalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/FlavourSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/FourVectors.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/FourthGenerationProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Fragmentation.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Frontpage.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Glossary.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/HadronLevelStandalone.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/HepMCInterface.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/HiddenValleyProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/HiggsProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Histograms.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ImplementNewShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Index.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/JetFinders.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/LeftRightSymmetryProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/LeptoquarkProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/LesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/MainProgramSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/MasterSwitches.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/MultipleInteractions.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/NewGaugeBosonProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/OniaProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/PDFSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/PYTHIA6TranslationTable.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ParticleData.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ParticleDataScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ParticleDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ParticleProperties.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/PartonDistributions.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/PhaseSpaceCuts.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ProcessSelection.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ProgramClasses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ProgramFiles.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ProgramFlow.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ProgramMethods.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/QCDProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ROOTusage.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/RandomNumberSeed.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/RandomNumbers.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ResonanceDecays.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SUSYLesHouchesAccord.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SUSYProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SampleMainPrograms.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SaveSettings.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SemiInternalProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SemiInternalResonances.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SettingsScheme.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/SpacelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/StandardModelParameters.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/TimelikeShowers.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/TopProcesses.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/TotalCrossSections.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Tunes.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/UpdateHistory.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/UserHooks.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Version.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/Welcome.xml [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ct09mc1.pds [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ct09mc2.pds [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ct09mcs.pds [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/cteq6l.tbl [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/cteq6l1.tbl [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/ctq66.00.pds [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/mrstlostar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/mrstlostarstar.00.dat [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/mstw2008lo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/mstw2008nlo.00.dat [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1FitA.data [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1FitB.data [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1FitBlo.data [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1JetsCharm.data [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1JetsGluon.data [new file with mode: 0644]
PYTHIA8/pythia8145/xmldoc/pomH1JetsSinglet.data [new file with mode: 0644]

diff --git a/PYTHIA8/pythia8145/AUTHORS b/PYTHIA8/pythia8145/AUTHORS
new file mode 100644 (file)
index 0000000..2eac938
--- /dev/null
@@ -0,0 +1,5 @@
+Torbjorn Sjostrand <torbjorn@thep.lu.se>
+Stefan Ask <Stefan.Ask@cern.ch>
+Richard Corke <richard.corke@thep.lu.se>
+Stephen Mrenna <mrenna@fnal.gov>
+Peter Skands <peter.skands@cern.ch>
diff --git a/PYTHIA8/pythia8145/COPYING b/PYTHIA8/pythia8145/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/pythia8145/GUIDELINES b/PYTHIA8/pythia8145/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/pythia8145/Makefile b/PYTHIA8/pythia8145/Makefile
new file mode 100644 (file)
index 0000000..5c170b0
--- /dev/null
@@ -0,0 +1,220 @@
+#
+# 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.
+TMPDIR=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. 
+
+$(TMPDIR)/%.o : $(SRCDIR)/%.cc
+       @mkdir -p $(TMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) -c -I$(INCDIR) $< -o $@
+
+$(TMPDIR)/archive/%.o : $(SRCDIR)/%.cc
+       @mkdir -p $(TMPDIR)/archive
+       $(CXX) $(CXXFLAGS) -c -I$(INCDIR) $< -o $@
+
+$(TMPDIR)/%.o : lhapdfdummy/%.cc
+       @mkdir -p $(TMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) -c -I$(INCDIR) $< -o $@
+
+$(TMPDIR)/archive/%.o : lhapdfdummy/%.cc
+       @mkdir -p $(TMPDIR)/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)
+  $(TMPDIR)/%.d : $(SRCDIR)/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(TMPDIR); \
+       $(CC) -M -I$(INCDIR) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*\.o/$(TMPDIR)\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+endif
+
+$(TMPDIR)/archive/%.d : $(SRCDIR)/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(TMPDIR)/archive; \
+       $(CC) -M -I$(INCDIR) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*\.o/$(TMPDIR)\/archive\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+objects := $(patsubst $(SRCDIR)/%.cc,$(TMPDIR)/%.o,$(wildcard $(SRCDIR)/*.cc))
+objectsarch := $(patsubst $(SRCDIR)/%.cc,$(TMPDIR)/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,$(TMPDIR)/%.o,$(wildcard lhapdfdummy/*.cc))
+objdumarch := $(patsubst lhapdfdummy/%.cc,$(TMPDIR)/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,$(TMPDIR)/%.d,$(wildcard $(SRCDIR)/*.cc))
+depsarch := $(patsubst $(SRCDIR)/%.cc,$(TMPDIR)/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)
+
+   $(TMPDIR)/%.o : hepmcinterface/%.cc config.mk
+       @mkdir -p $(TMPDIR)
+       $(CXX) $(CXXFLAGS) $(CXXFLAGSSHARED) $(HEPMCVFLAG) -c -I$(INCDIR) $(HEPMCINCLUDE) $< -o $@
+
+   $(TMPDIR)/archive/%.o : hepmcinterface/%.cc config.mk
+       @mkdir -p $(TMPDIR)/archive
+       $(CXX) $(CXXFLAGS) $(HEPMCVFLAG) -c -I$(INCDIR) $(HEPMCINCLUDE) $< -o $@
+
+   $(TMPDIR)/%.d : hepmcinterface/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(TMPDIR); \
+       $(CC) -M -I$(INCDIR) $(HEPMCINCLUDE) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*.o/$(TMPDIR)\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+   $(TMPDIR)/archive/%.d : hepmcinterface/%.cc
+       @echo Making dependency for file $<; \
+       mkdir -p $(TMPDIR)/archive; \
+       $(CC) -M -I$(INCDIR) $(HEPMCINCLUDE) $< | \
+       sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' | \
+       sed 's/$*.o/$(TMPDIR)\/archive\/$*.o/' > $@; \
+       [ -s $@ ] || rm -f $@
+
+   objectsI := $(patsubst hepmcinterface/%.cc,$(TMPDIR)/%.o,$(wildcard hepmcinterface/*.cc))
+   objectsIarch := $(patsubst hepmcinterface/%.cc,$(TMPDIR)/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,$(TMPDIR)/%.d,$(wildcard hepmcinterface/*.cc))
+   depsIarch := $(patsubst hepmcinterface/%.cc,$(TMPDIR)/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
+
+# Clean up: remove (almost?) everything that cannot be recreated.
+
+.PHONY: clean distclean
+
+clean:
+       rm -rf $(TMPDIR)
+       rm -rf $(LIBDIR)
+       rm -rf $(BINDIR)
+       cd examples; 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 -
+
diff --git a/PYTHIA8/pythia8145/Makefile.msc b/PYTHIA8/pythia8145/Makefile.msc
new file mode 100644 (file)
index 0000000..6025c92
--- /dev/null
@@ -0,0 +1,161 @@
+# 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)/Info.obj \
+         $(OUTDIR)/LesHouches.obj \
+         $(OUTDIR)/MiniStringFragmentation.obj \
+         $(OUTDIR)/MultipleInteractions.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)/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)/TimeShower.obj \
+         $(OUTDIR)/UserHooks.obj \
+         $(OUTDIR)/LHAPDFDummy.obj
+# If you link to LHAPDF you don't want the last line
+# If you link to HepMC you also need HepMCInterface
+
+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/pythia8145/README b/PYTHIA8/pythia8145/README
new file mode 100644 (file)
index 0000000..395f604
--- /dev/null
@@ -0,0 +1,143 @@
+
+   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 slc4_ia32_gcc34 while other supported
+         values for name include slc4_amd64_gcc34 and slc3_ia32_gcc323
+         (deprecated). 
+     --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"
+     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.
+
+----------------------------------------------------------------------
+
+   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/pythia8145/README.HepMC b/PYTHIA8/pythia8145/README.HepMC
new file mode 100644 (file)
index 0000000..e796db5
--- /dev/null
@@ -0,0 +1,57 @@
+How to install HepMC on your laptop (Linux/Mac OSX) and link to Pythia
+
+Note 1: Comes with no guarantee; this is what worked for me.
+Note 2: refers to HepMC 2.04.02 and Pythia 8.125 as of June 2009,
+        but should work also for later versions.
+
+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 pythia8125 (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. main32 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/pythia8145/README.Win32 b/PYTHIA8/pythia8145/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/pythia8145/configure b/PYTHIA8/pythia8145/configure
new file mode 100755 (executable)
index 0000000..dcd23f8
--- /dev/null
@@ -0,0 +1,328 @@
+#!/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=slc4_ia32_gcc34
+fi
+
+# Defaults
+export COMPMODE=OPT
+export SHAREDLIBS=no
+
+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--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 slc4_ia32_gcc34"
+    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
+    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)"
+    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-hepmcversion" ] ; then
+      HEPMCVERSION=${value}
+    elif [ "x${option}" = "x--with-hepmc" ] ; then
+      HEPMCLOCATION=${value}
+    else
+      echo "${arg}: wrong option. Ignored." >&2
+    fi
+  fi
+done
+
+echo compilation mode is $COMPMODE
+echo sharedlibs = $SHAREDLIBS
+
+# Environment variables for building HepMC interface library. Note that
+# the HepMC interface library is used by the examples main31, main32.
+# 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 specifyed, 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  -----------------------------
+#
+
+# export FFLAGS_OPT="-O2 -Wuninitialized"
+# -Wuninitialized outputs many irrelevant warnings and therefore obscurs 
+export FFLAGS_OPT="-O2 -fbounds-check"
+export FFLAGS_DBG=-g
+export CFLAGS_OPT="-O2 -fbounds-check"
+export CFLAGS_DBG=-g
+export CXXFLAGS_OPT="-O2 -ansi -pedantic -W -Wall -Wshadow -fbounds-check ${ENABLE64}"
+export CXXFLAGS_DBG="-g -ansi -pedantic -W -Wall -Wshadow -fbounds-check ${ENABLE64}"
+#
+# 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
+LDFLAGSSHARED="${CXXFLAGS} -pthread -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} -pthread -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} -pthread -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
+
+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
+#
+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
diff --git a/PYTHIA8/pythia8145/examples/Makefile b/PYTHIA8/pythia8145/examples/Makefile
new file mode 100644 (file)
index 0000000..8930f63
--- /dev/null
@@ -0,0 +1,110 @@
+#
+# Examples Makefile.
+#
+#                  M. Kirsanov 07.04.2006
+#                     Modified 18.11.2006
+#                     26.03.2008 CLHEP dependency removed
+
+SHELL = /bin/sh
+
+-include ../config.mk
+-include config.mk
+
+# Location of directories.
+TMPDIR=tmp
+TOPDIR=$(shell \pwd)
+INCDIR=include
+SRCDIR=src
+LIBDIR=lib
+LIBDIRARCH=lib/archive
+BINDIR=bin
+
+# 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 \
+       main44 main71 main72 \
+       test234 test235 test236 test237 test238 test239 test240 test241 \
+       test242 test243 test244 test245 test246 test247 test248 test249 \
+       test250 test251 test252 test253 test254 test254a test255 test256 \
+       test257 test258 test259 test260 test261 test262 test263 test264 \
+       test265 test266 test267 test268 test269 test270 test271 test272 \
+       test273 test274 test275 test276 test277 test278 test279 test280 \
+       test281 test282 test283 test284 test285 test286 test287 test288 \
+       test289 test290 test291 test292 test293 test294 test295 test296: \
+       ../$(LIBDIRARCH)/libpythia8.a
+       @mkdir -p ../$(BINDIR)
+       $(CXX) $(CXXFLAGS) -I../$(INCDIR) $@.cc -o ../$(BINDIR)/$@.exe \
+       -L../$(LIBDIRARCH) -lpythia8 -llhapdfdummy
+       @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)
+  main31 main32: \
+       ../$(LIBDIRARCH)/libpythia8.a ../$(LIBDIRARCH)/libhepmcinterface.a
+       @mkdir -p ../$(BINDIR)
+       $(CXX) $(CXXFLAGS) -Wno-shadow -I../$(INCDIR) -I$(HEPMCLOCATION)/include \
+       $@.cc -o ../$(BINDIR)/$@.exe \
+       -L../$(LIBDIRARCH) -lpythia8 -llhapdfdummy \
+       -lhepmcinterface \
+       -L$(HEPMCLOCATION)/lib -lHepMC
+       @ln -fs ../$(BINDIR)/$@.exe $@.exe
+else
+  main31 main32:
+       @echo ERROR, this target needs HepMC, variable HEPMCLOCATION
+endif
+
+# Create an executable that links to LHAPDF
+main41 main42 main43: ../$(LIBDIRARCH)/libpythia8.a
+       @mkdir -p ../$(BINDIR)
+       $(CXX) $(CXXFLAGS) -I../$(INCDIR) $@.cc -o ../$(BINDIR)/$@.exe \
+       -L../$(LIBDIRARCH) -lpythia8 \
+       -L$(LHAPDFLOCATION) $(LHAPDFLIBNAME) \
+       $(FLIBS)
+       @ln -fs ../$(BINDIR)/$@.exe $@.exe
+
+# 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.
+#main51: ../$(LIBDIRARCH)/libpythia8.a
+#      @mkdir -p ../$(BINDIR)
+#      $(CXX) $(CXXFLAGS) -I../$(INCDIR) $@.cc -o ../$(BINDIR)/$@.exe \
+#      -L../$(LIBDIRARCH) -lpythia8 -llhapdfdummy \
+#      -L/directoryoflibpythia6.a -lpythia6 \
+#      $(FLIBS)
+#      @ln -fs ../$(BINDIR)/$@.exe $@.exe
+
+# Create an executable that links to Fastjet
+# Owing to excessive warning output -Wshadow is not used for Fastjet.
+ifneq (x$(FASTJETLOCATION),x)
+  main61: ../$(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../$(INCDIR) $@.cc \
+       `$(FASTJETLOCATION)/bin/fastjet-config --cxxflags --plugins` \
+       $(CXXFLAGS) -Wno-shadow \
+       -o ../$(BINDIR)/$@.exe \
+       -L../$(LIBDIRARCH) -lpythia8 -llhapdfdummy \
+       -L$(FASTJETLOCATION)/lib \
+       `$(FASTJETLOCATION)/bin/fastjet-config --libs --plugins`
+       @ln -fs ../$(BINDIR)/$@.exe $@.exe
+       @rm -f $@.o
+else
+  main61:
+       @echo ERROR, this target needs Fastjet, variable FASTJETLOCATION
+endif
+
+# 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/pythia8145/examples/README b/PYTHIA8/pythia8145/examples/README
new file mode 100644 (file)
index 0000000..86b58a2
--- /dev/null
@@ -0,0 +1,145 @@
+----------------------------------------------------------------------
+
+   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 twentynine of the mainNN 
+   examples listed below. 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.
+
+4) 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,  
+   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)
+     --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.
+
+----------------------------------------------------------------------
+
+   LIST OF TEST PROGRAMS
+
+1) main01 - main20, main28 - main30, main71 only use the PYTHIA 8 library
+* main01.cc : brief example with charged multiplicity distribution
+* main02.cc : brief example with Z0 pT spectrum
+* main03.cc & main03.cmnd : simple single-particle analysis in jet events
+* main04.cc & main04.cmnd : simple tests of event properties
+* main05.cc : cone-jet analysis of LHC events
+* main06.cc & main06.cmnd : study elastic/diffractive events
+* main07.cc & main07.cmnd : study minimum-bias events
+* main08.cc & main08.cmnd  : combine results of subruns in separate pT bins
+* main09.cc : LEP events with sphericity/thrust/jetfinder analysis
+* main10.cc : implement UserHooks to interact with the generation process
+* main11.cc : set two hard interactions in the same event
+* main12.cc & ttbar.lhe : generate events from a Les Houches Event File 
+* main13.cc & ttbar.lhe & ttbar2.lhe : several Les Houches Event Files & more 
+* main14.cc : compare several cross sections with their PYTHIA 6.4 values. 
+* main15.cc : redo B decays or hadronization several times for each event
+* main16.cc : user analysis class; command-line specification of input file  
+* main17.cc : Pythia wrapper class; command-line specification of input file
+* main18.cc : event filter class to retain a subset of the particles 
+* main19.cc : use two Pythia instances to combine signal and pileup events
+* main20.cc : write a Les Houches Event File with PYTHIA 8-generated events 
+* main22.cc & main22.cmnd & sps1a.spc : SUSY using SLHA, internal cross sections
+* main28.cc : test program for large extra dimensions or unparticles
+* main29.cc : generic "energy blob" decay for cosmic-ray physics  
+* main30.cc : Kaluza-Klein gamma/Z states in TeV-sized extra dimensions
+* main71.cc & powheg-hvq.lhe : interface to POWHEG events
+* main72.cc & main72.lhe : RPV-SUSY from LHEF with color junctions
+
+2) main21 - main27 are examples how some external programs could be linked
+* main21.cc : external input of parton configurations for hadronization only
+* main23.cc : how to link an external decay handler
+* main24.cc : how to link an external random number generator
+* main25.cc : how to link an external process to use internally
+* main26.cc : how to link an external resonance and process to use internally
+* main27.cc : how to link an external momentum spread and vertex generator 
+
+3) main31 - main32 require linkage to the HepMC event record library
+* main31.cc & main31.cmnd : simple example output to HepMC 
+* main32.cc & main32.cmnd : streamlined production of a HepMC event file
+
+4) main41 - main43 require linkage to LHAPDF
+* main41.cc : test shape of PDF's
+* main42.cc : compare average multiplicity and pT for different PDF's
+* main43.cc : example of evolution with photon-in-proton: the MRST2004qed set
+* main44.cc : how to create your own PDF and link it in for usage
+
+5) main51.cc requires linkage to Pythia 6.4, and is deprecated  
+
+6) main61 requires linkage to FastJet
+* main61.cc : rate of W + jets events using kT-clustering for jets 
+Note 1: main31 and main32 save HepMC-formatted events on hepmcoutNN.dat;     
+    these files become so big that they have not been included in the 
+    distribution. 
+Note 2: There is no main00 program, but main00 is defined in the 
+    Makefile to link to PYTHIA 8, so this name can be used for 
+    simple first tests.
+Note 3: With ./runmains all the 30 first mainXX program will be run,
+    plus main71, 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.
+
+----------------------------------------------------------------------
diff --git a/PYTHIA8/pythia8145/examples/configure b/PYTHIA8/pythia8145/examples/configure
new file mode 100644 (file)
index 0000000..e120101
--- /dev/null
@@ -0,0 +1,408 @@
+#!/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=slc4_ia32_gcc34
+fi
+
+# Defaults
+export COMPMODE=OPT
+
+# 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-lhapdf=lhapdfpath : path to LHAPDF libraries (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-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
+  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 [ $?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
+#
+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
+
+
+#
+#
+# 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/pythia8145/examples/main01.cc b/PYTHIA8/pythia8145/examples/main01.cc
new file mode 100644 (file)
index 0000000..c7f4508
--- /dev/null
@@ -0,0 +1,33 @@
+// main01.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This 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("HardQCD:all = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 20.");  
+  pythia.init( 2212, 2212, 14000.);
+  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;
+    if (iEvent < 1) {pythia.info.list(); pythia.event.list();} 
+    // 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.statistics();
+  cout << mult; 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main02.cc b/PYTHIA8/pythia8145/examples/main02.cc
new file mode 100644 (file)
index 0000000..16ca589
--- /dev/null
@@ -0,0 +1,33 @@
+// main02.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This 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("WeakSingleBoson:ffbar2gmZ = on");    
+  pythia.readString("PhaseSpace:mHatMin = 80.");    
+  pythia.readString("PhaseSpace:mHatMax = 120.");    
+  pythia.init( 2212, -2212, 1960.);
+  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;
+    if (iEvent < 1) {pythia.info.list(); pythia.event.list();}
+    // 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.statistics();
+  cout << pTZ; 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main03.cc b/PYTHIA8/pythia8145/examples/main03.cc
new file mode 100644 (file)
index 0000000..ab35c17
--- /dev/null
@@ -0,0 +1,92 @@
+// main03.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates a simple analysis of QCD jet events.
+// All input is specified in the main03.cmnd file.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Generator.
+  Pythia pythia;
+
+  // Shorthand for some public members of pythia.
+  Event& event      = pythia.event;
+  ParticleData& pdt = pythia.particleData;
+  Info& info        = pythia.info;
+
+  // 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    nList   = pythia.mode("Main:numberToList");
+  int    nShow   = pythia.mode("Main:timesToShow");
+  bool   showCS  = pythia.flag("Main:showChangedSettings");
+  bool   showCPD = pythia.flag("Main:showChangedParticleData");
+
+  // Initialize. Beam parameters set in .cmnd file.
+  pythia.init();
+
+  // List changed data.
+  if (showCS)  pythia.settings.listChanged();
+  if (showCPD) pdt.listChanged();
+
+  // Book histograms.
+  Hist pThard("process pT scale", 100, 0., 200.);
+  Hist mult("charged particle multiplicity", 100, -0.5, 799.5);
+  Hist dndy("dn/dy for charged particles", 100, -10., 10.);
+  Hist dndpT("dn/dpT for charged particles", 100, 0., 10.);
+
+  // Begin event loop.
+  int nPace = max(1, nEvent / max(1, nShow) ); 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if failure.
+    if (!pythia.next()) {
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both info, hard process and complete events.
+    if (iEvent < nList) { 
+      info.list();
+      pythia.process.list();
+      event.list();
+    }
+
+    // Fill hard scale of event.
+    pThard.fill( info. pTHat() );
+
+    // Loop over final charged particles in the event. 
+    int nCharged = 0;
+    for (int i = 0; i < event.size(); ++i) 
+    if (event[i].isFinal() && event[i].isCharged()) {
+
+      // Analyze charged particles and fill histograms.
+      ++nCharged;
+      dndy.fill( event[i].y() );
+      dndpT.fill( event[i].pT() );
+
+    // End of particle and event loops. Fill charged multiplicity.
+    }
+    mult.fill( nCharged );
+  }
+
+  // Final statistics. Normalize and output histograms.
+  pythia.statistics();
+  dndy *= 5. / nEvent;
+  dndpT *= 10. / nEvent;
+  cout << pThard << mult << dndy << dndpT; 
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main03.cmnd b/PYTHIA8/pythia8145/examples/main03.cmnd
new file mode 100644 (file)
index 0000000..0f205a6
--- /dev/null
@@ -0,0 +1,30 @@
+! main03.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:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+Main:showChangedParticleData = on  ! print changed particle and decay data
+
+! 2) 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
+
+! 3) Settings for the hard-process generation.
+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 sacale in process 
+
+! 4) Settings for the event generation process in the Pythia8 library.
+#PartonLevel:MI = off               ! no multiple interactions
+#PartonLevel:ISR = off              ! no initial-state radiation 
+#PartonLevel:FSR = off              ! no final-state radiation
+#HadronLevel:Hadronize = off        ! no hadronization
+
+! 5) Non-standard settings; exemplifies tuning possibilities.
+#SpaceShower:pT0Ref = 2.0           ! dampening of pT -> 0 divergence
+#MultipleInteractions:pT0Ref = 3.0  ! dampening of pT -> 0 divergence
diff --git a/PYTHIA8/pythia8145/examples/main04.cc b/PYTHIA8/pythia8145/examples/main04.cc
new file mode 100644 (file)
index 0000000..6a4595c
--- /dev/null
@@ -0,0 +1,98 @@
+// main04.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how different processes can be selected and studied.
+// All input is specified in the main04.cmnd file.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Generator. Shorthand for the event and the (static) Settings.
+  Pythia pythia;
+  Event& event = pythia.event;
+  Settings& settings = pythia.settings;
+
+  // 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    nList   = pythia.mode("Main:numberToList");
+  int    nShow   = pythia.mode("Main:timesToShow");
+  int    nAbort  = pythia.mode("Main:timesAllowErrors");
+  bool   showCS  = pythia.flag("Main:showChangedSettings");
+  bool   showAS  = pythia.flag("Main:showAllSettings");
+
+  // Also need the CM energy.
+  double eCM     = pythia.parm("Beams:eCM");
+
+  // Initialization using beam parameters in the .cmnd file.
+  pythia.init();
+
+  // List changed or all data.
+  if (showCS) settings.listChanged();
+  if (showAS) settings.listAll();
+
+  // Histograms.
+  double epTol = 1e-6 * eCM;
+  Hist epCons("deviation from energy-momentum conservation",100,0.,epTol);
+  Hist nFinal("final particle multiplicity",100,-0.5,799.5);
+  Hist dNdEta("dn/deta for particles",100,-10.,10.);
+
+  // Begin event loop.
+  int nPace = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if failure.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both hard process and complete events.
+    if (iEvent < nList) {
+      pythia.info.list(); 
+      pythia.process.list();
+      event.list();
+    }
+
+    // Loop over final particles in the event. 
+    int nFin = 0;
+    Vec4 pSum;
+    for (int i = 0; i < event.size(); ++i) if (event[i].isFinal()) {
+      nFin++;
+      pSum += event[i].p();
+      dNdEta.fill(event[i].eta());
+    }
+
+    // Check and print event with too big energy-momentum deviation.
+    nFinal.fill(nFin);
+    double epDev = abs(pSum.e() - eCM) + abs(pSum.px()) + abs(pSum.py())
+      + abs(pSum.pz());
+    epCons.fill(epDev);
+    if (epDev > epTol) {
+      cout << " Warning! Event with epDev = " << scientific 
+           << setprecision(4) << epDev << " now listed:";
+      event.list();
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics and histogram output.
+  pythia.statistics();
+  dNdEta *= 5./nEvent;
+  cout << epCons << nFinal << dNdEta; 
+
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main04.cmnd b/PYTHIA8/pythia8145/examples/main04.cmnd
new file mode 100644 (file)
index 0000000..f25b6e0
--- /dev/null
@@ -0,0 +1,41 @@
+! main04.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 that could be used in a main program, if desired.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is
+Main:timesAllowErrors = 3          ! how many aborts before run stops
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+Main:showAllSettings = off         ! print all flags/modes/parameters
+
+! 2) 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
+
+! 3) Settings for the hard-process generation.
+! Example 1: QCD production; must set pTmin. 
+#HardQCD:all = on                   !  switch on all QCD jet + jet processes
+#PhaseSpace:pTHatMin = 20.          ! minimal pT sacale 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           ! q qbar -> Z0 W+- 
+#WeakDoubleBoson:ffbar2WW           ! q qbar -> W+ W-
+
+! 4) Settings for the event generation process in the Pythia8 library.
+#PartonLevel:MI = off               ! no multiple 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
+
+! 5) Non-standard settings; exemplifies tuning possibilities.
+#SpaceShower:pT0Ref = 2.0           ! dampening of pT -> 0 divergence
+#MultipleInteractions:pT0Ref = 3.0  ! dampening of pT -> 0 divergence
diff --git a/PYTHIA8/pythia8145/examples/main05.cc b/PYTHIA8/pythia8145/examples/main05.cc
new file mode 100644 (file)
index 0000000..7771a67
--- /dev/null
@@ -0,0 +1,96 @@
+// main05.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It studies jet production at the LHC, using CellJet.
+
+#include "Pythia.h"
+using namespace Pythia8;
+int main() {
+
+  // Number of events, generated and listed ones.
+  int nEvent    = 200;
+  int nList     = 0;
+  int nListJets = 5;
+
+  // Generator. Process selection. LHC initialization.
+  Pythia pythia;
+  pythia.readString("HardQCD:all = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 200.");    
+  pythia.init( 2212, 2212, 14000.);
+
+  // Range and granularity of jet finder.
+  double etaMax     = 4.;
+  int    nEta       = 80;
+  int    nPhi       = 64;
+  // Exclude neutrinos (and other invisible) from study
+  int    nSel       = 2;
+  // Character and amount of energy smearing, cell by cell.
+  int    smear      = 2;
+  double resolution = 0.3;
+  double upperCut   = 2.;
+  double threshold  = 0.1;
+  Rndm*  rndmPtr    = &pythia.rndm;
+  // The  jet finder itself. 
+  CellJet cellJet( etaMax, nEta, nPhi, nSel, smear, resolution,
+    upperCut, threshold, rndmPtr);
+
+  // Histograms.
+  Hist nJets("number of jets", 20, -0.5, 19.5);
+  Hist eTjets("eT for jets", 100, 0., 500.);
+  Hist etaJets("eta for jets", 100, -5., 5.);
+  Hist phiJets("phi for jets", 100, -M_PI, M_PI);  
+  Hist distJets("R distance between jets", 100, 0., 10.);
+  Hist eTdiff("eT difference", 100, -100., 400.);
+
+  // Begin event loop. Generate event. Skip if error. list first few. 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (!pythia.next()) continue;
+
+    // List first few events.
+    if (iEvent < nList) {
+      pythia.info.list(); 
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+    // Analyze jet properties. List first few. 
+    cellJet. analyze( pythia.event );
+    if (iEvent < nListJets) cellJet.list();
+
+    // Fill inclusive jet distributions.
+    nJets.fill( cellJet.size() );
+    for (int i = 0; i < cellJet.size(); ++i) {
+      eTjets.fill( cellJet.eT(i) );
+      etaJets.fill( cellJet.etaWeighted(i) );
+      phiJets.fill( cellJet.phiWeighted(i) );
+    }
+
+    // Fill 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) );
+      distJets.fill( dR );
+    }
+
+    // Fill ET-difference between jets (to check ordering of list).
+    for (int i = 1; i < cellJet.size(); ++i) 
+      eTdiff.fill( cellJet.eT(i-1)- cellJet.eT(i) );
+
+  // End of event loop. Statistics. Histograms. 
+  }
+  pythia.statistics();
+  cout << nJets << eTjets << etaJets << phiJets 
+       << distJets << eTdiff;
+
+  // Done. 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main06.cc b/PYTHIA8/pythia8145/examples/main06.cc
new file mode 100644 (file)
index 0000000..8eac4b5
--- /dev/null
@@ -0,0 +1,137 @@
+// main06.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how to use internal Pythia8 processes,
+// with special emphasis on elastic/diffractive processes.
+// All input is specified in the main06.cmnd file.
+
+#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("main06.cmnd");    
+
+  // Extract settings to be used in the main program.
+  int    nEvent    = pythia.mode("Main:numberOfEvents");
+  int    nList     = pythia.mode("Main:numberToList");
+  int    nShow     = pythia.mode("Main:timesToShow");
+  int    nAbort    = pythia.mode("Main:timesAllowErrors");
+  bool   showCS    = pythia.flag("Main:showChangedSettings");
+  bool   showAS    = pythia.flag("Main:showAllSettings");
+  bool   showCPD   = pythia.flag("Main:showChangedParticleData");
+  bool   showAPD   = pythia.flag("Main:showAllParticleData");
+
+  // Debug: kill Coulomb part but keep rest of elastic description. 
+  //pythia.settings.forceParm("StandardModel:alphaEM0", 1e-10);
+  //pythia.settings.forceParm("StandardModel:alphaEMmZ", 1e-10);
+  // Initialize. Beam parameters set in .cmnd file.
+  pythia.init();
+
+  // List settings.
+  if (showCS) pythia.settings.listChanged();
+  if (showAS) pythia.settings.listAll();
+
+  // List particle data.  
+  if (showCPD) pythia.particleData.listChanged();
+  if (showAPD) pythia.particleData.listAll();
+
+  // Book histograms.
+  Hist pTspec("scattering pT spectrum", 100, 0., 2.5); 
+  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 mSpec("scattering mass spectrum", 100, 0., 100.); 
+  Hist mLogSpec("log10(scattering mass spectrum)", 100, 0., 4.); 
+  Hist nChg("number of charged particles in diffractive event", 
+    100, -0.5, 99.5);
+  Hist nDiff("number of final particles in diffractive system", 
+    100, -0.5, 99.5);
+  Hist mSpec1("scattering mass spectrum when 1 product", 100, 0., 10.); 
+  // Begin event loop.
+  int nPace = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0; 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if too many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both hard process and complete events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      event.list();
+    }
+
+    // Study generic event properties.
+    double pT = pythia.info.pTHat();
+    pTspec.fill( pT );
+
+    // Study properties geared towards elastic/diffractive events.
+    mSpec.fill( event[3].m() );
+    mSpec.fill( event[4].m() );
+    mLogSpec.fill( log10(event[3].m()) );
+    mLogSpec.fill( log10(event[4].m()) );
+    int code = pythia.info.code();
+    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);
+
+    // Study properties geared towards minimum-bias or jet physics.
+    int nch = 0;
+    for (int i = 1; i < event.size(); ++i)
+      if (event[i].isFinal() && event[i].isCharged()) ++nch; 
+    if (code != 102) nChg.fill( nch );
+
+    // Multiplicity distribution in diffractive system.
+    for (int i = 0; i < 2; ++i) 
+    if ( (i == 0 && pythia.info.isDiffractiveA()) 
+      || (i == 1 && pythia.info.isDiffractiveB()) ) {
+      int ndiff = 0;
+      for (int j = 5; j < event.size(); ++j) 
+      if (event[j].isFinal()) {
+        // Trace back final particle to see which system it comes from.
+        int k = j;
+        do k = event[k].mother1(); 
+        while (k > 4);
+        if (k == i + 3) ++ndiff;
+      }  
+      nDiff.fill( ndiff );
+      if (ndiff <= 1) mSpec1.fill( event[i+3].m() ); 
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics and histograms.
+  pythia.statistics();
+  cout << pTspec << tSpecEl << tSpecElLog << tSpecSD << tSpecDD << mSpec 
+       << mLogSpec << nChg << nDiff << mSpec1;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main06.cmnd b/PYTHIA8/pythia8145/examples/main06.cmnd
new file mode 100644 (file)
index 0000000..31e4f2b
--- /dev/null
@@ -0,0 +1,38 @@
+! File: main06.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 that could be used in a main program, if desired.
+Main:numberOfEvents = 20000        ! number of events to generate
+Main:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is this many times
+Main:timesAllowErrors = 10         ! abort run after this many flawed events
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+#Main:showAllSettings = on          ! print all flags/modes/parameters
+#Main:showChangedParticleData = on  ! print changed particle and decay data
+#Main:showAllParticleData = on      ! print all particle and decay data
+
+! 2) 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
+
+! 3) Settings for process generation internal to Pythia8.
+SoftQCD:elastic = on               ! elastic scattering
+SoftQCD:singleDiffractive = on     ! single diffractive scattering
+SoftQCD:doubleDiffractive = on     ! double diffractive scattering
+
+! 4) 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/diffractive sigma
+SigmaTotal:sigmaTot = 106.         ! total cross section (excluding Coulomb)
+SigmaTotal:sigmaXX = 3.            ! reduce double diffractive cross section 
+SigmaElastic:setOwn = on           ! suboption for Coulomb term in elastic
+SigmaElastic:tAbsMin = 4e-5        ! divergence requires lower cutoff
+
+! 5) Switch off some key components of the simulation, for comparisons.
+#PartonLevel:all = off              ! stop after hard process 
+
+
diff --git a/PYTHIA8/pythia8145/examples/main07.cc b/PYTHIA8/pythia8145/examples/main07.cc
new file mode 100644 (file)
index 0000000..5efd49f
--- /dev/null
@@ -0,0 +1,134 @@
+// main07.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how to generate and analyze minimum-bias events.
+// All input is specified in the main07.cmnd file.
+
+#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("main07.cmnd");    
+
+  // Extract settings to be used in the main program.
+  int    nEvent    = pythia.mode("Main:numberOfEvents");
+  int    nList     = pythia.mode("Main:numberToList");
+  int    nShow     = pythia.mode("Main:timesToShow");
+  int    nAbort    = pythia.mode("Main:timesAllowErrors");
+  bool   showCS    = pythia.flag("Main:showChangedSettings");
+  bool   showAS    = pythia.flag("Main:showAllSettings");
+  bool   showCPD   = pythia.flag("Main:showChangedParticleData");
+  bool   showAPD   = pythia.flag("Main:showAllParticleData");
+  bool   showAStat = pythia.flag("Main:showAllStatistics");
+  // Initialize. Beam parameters set in .cmnd file.
+  pythia.init();
+
+  // List changed data.
+  if (showCS) pythia.settings.listChanged();
+  if (showAS) pythia.settings.listAll();
+
+  // List particle data.  
+  if (showCPD) pythia.particleData.listChanged();
+  if (showAPD) pythia.particleData.listAll();
+
+  // Book histograms.
+  double pTmax = 20.;
+  double bMax = 4.;
+  Hist nChg("number of charged particles", 100, -0.5, 799.5);
+  Hist nChg1("number of charged particles in |eta| < 1", 100, -0.5, 99.5);
+  Hist pTnChg1("<pT>(n_charged) in |eta| < 1", 100, -0.5, 99.5);
+  Hist pTspec("scattering pT 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 nPace = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0; 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if too many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both hard process and complete events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      event.list();
+    }
+
+    // Charged multiplicity. It and pT in central rapidity range.
+    int    nch     = 0;
+    int    nch1    = 0;
+    double pTsum1  = 0.;
+    for (int i = 1; i < event.size(); ++i)
+    if (event[i].isFinal() && event[i].isCharged()) { 
+      ++nch;
+      if ( abs(event[i].eta()) < 1.) {
+        ++nch1;
+        pTsum1 += event[i].pT();
+      }
+    }    
+    nChg.fill( nch );
+    nChg1.fill( nch1 );
+    if (nch1 > 0) pTnChg1.fill( nch1, pTsum1 / nch1 );
+
+    // Study event in (pT, b) space.
+    double pT = pythia.info.pTHat(); 
+    double b = pythia.info.bMI();
+    double enhance = pythia.info.enhanceMI();
+    int nMI = pythia.info.nMI();
+    pTspec.fill( pT );
+    bSpec.fill( b );
+    enhanceSpec.fill( enhance );
+    number.fill( nMI );
+    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.
+  pythia.statistics(showAStat);
+  pTnChg1 /= nChg1;
+  cout << nChg << nChg1 << pTnChg1 << pTspec << bSpec 
+       << enhanceSpec << number;
+  cout << pTb1 << pTb2 << pTb3 << pTb4;
+  cout << bpT1 << bpT2 << bpT3 << bpT4;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main07.cmnd b/PYTHIA8/pythia8145/examples/main07.cmnd
new file mode 100644 (file)
index 0000000..59bbe9f
--- /dev/null
@@ -0,0 +1,48 @@
+! File: main07.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 that could be used in a main program, if desired.
+Main:numberOfEvents = 1000        ! number of events to generate
+Main:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is this many times
+Main:timesAllowErrors = 10         ! abort run after this many flawed events
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+#Main:showAllSettings = on          ! print all flags/modes/parameters
+#Main:showChangedParticleData = on  ! print changed particle and decay data
+#Main:showAllParticleData = on      ! print all particle and decay data
+Main:showAllStatistics = on        ! more statistics on multiple interactions
+
+! 2) 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
+
+! 3) Settings for hard-process generation internal to Pythia8.
+SoftQCD:minbias = on               ! minimum bias QCD processes
+#HardQCD:all = on                    ! QCD jet production
+#PhaseSpace:pTHatMin = 20.           ! minimum pT in hard process
+
+! 4) Switch off some key components of the simulation, for comparisons.
+#PartonLevel:all = off              ! stop after hard process 
+#PartonLevel:MI = off               ! no multiple 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
+
+! 5) Multiple interactions and impact parameter picture.
+! Note: these values are illustrative only, not to be taken seriously.
+MultipleInteractions:pT0Ref = 2.
+MultipleInteractions:ecmRef = 1960.
+MultipleInteractions:ecmPow = 0.16
+MultipleInteractions:pTmin = 0.2
+MultipleInteractions:bProfile = 2   
+#MultipleInteractions:coreRadius = 0.4
+#MultipleInteractions:coreFraction = 0.5
+MultipleInteractions:expPow = 1.
+
+! 6) Switch off checks.
+#Check:event = off
diff --git a/PYTHIA8/pythia8145/examples/main08.cc b/PYTHIA8/pythia8145/examples/main08.cc
new file mode 100644 (file)
index 0000000..21dc867
--- /dev/null
@@ -0,0 +1,112 @@
+// main08.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how to combine subruns in pT bins.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+int main() {
+
+  // Two 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.
+  int mode = 2;
+
+  // Number of events to generate per bin, and to list.
+  int nEvent = 10000;
+  int nList = 1;
+
+  // Book histograms.
+  Hist pTraw("pTHat distribution, unweighted", 100, 0., 1000.);
+  Hist pTnorm("pTHat distribution, weighted", 100, 0., 1000.);
+  Hist pTpow3("pTHat distribution, pT3*weighted", 100, 0., 1000.);
+  Hist pTpow5("pTHat distribution, pT5*weighted", 100, 0., 1000.);
+  Hist pTnormPart("pTHat distribution, weighted", 100, 0., 1000.);
+  Hist pTpow3Part("pTHat distribution, pT3*weighted", 100, 0., 1000.);
+  Hist pTpow5Part("pTHat distribution, pT5*weighted", 100, 0., 1000.);
+
+  // Generator.
+  Pythia pythia;
+
+  // Shorthand for some public members of pythia (also static ones).
+  Settings& settings = pythia.settings;
+  Info& info = pythia.info;
+
+  // Set up to generate QCD jets.
+  pythia.readString("HardQCD:all = on");  
+  pythia.readString("PartonLevel:all = off");  
+
+  // 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");
+  } 
+
+  // Mode 1: set up five pT bins - last one open-ended.
+  double pTlimit[6] = {100., 150., 250., 400., 600., 0.};
+
+  // Loop over number of bins, i.e. number of subruns.
+  for (int iBin = 0; iBin < nBin; ++iBin) {
+
+     // Mode 1: hardcoded here. Using settings.parm allows 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 pythia.readFile("main08.cmnd", iBin);  
+
+     // Initialize for LHC.
+     pythia.init( 2212, 2212, 14000.);
+
+    // List changed data.
+    settings.listChanged();
+
+    // 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;
+      // List first few events, only hard process.
+      if (iEvent < nList) pythia.process.list();
+
+      // Fill hard scale of event.
+      double pTHat = info. pTHat();
+      pTraw.fill( pTHat );
+      pTnormPart.fill( pTHat );
+      pTpow3Part.fill( pTHat, pow3(pTHat) );
+      pTpow5Part.fill( pTHat, pow5(pTHat) );
+
+
+    // End of event loop. Statistics.
+    }
+    pythia.statistics();
+
+    // Normalize each case to cross section/(bin * event), and add to sum.
+    double sigmaNorm = info.sigmaGen() / (10. * nEvent);
+    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/pythia8145/examples/main08.cmnd b/PYTHIA8/pythia8145/examples/main08.cmnd
new file mode 100644 (file)
index 0000000..44f374c
--- /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/pythia8145/examples/main09.cc b/PYTHIA8/pythia8145/examples/main09.cc
new file mode 100644 (file)
index 0000000..3c43535
--- /dev/null
@@ -0,0 +1,139 @@
+// main09.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This 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. 
+  double mZ = pythia.particleData.m0(23);  
+  pythia.init( 11, -11, mZ);
+
+  // Check that Z0 decay channels set correctly.
+  pythia.particleData.listChanged();
+
+  // 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;
+    if (iEvent < 1) pythia.event.list();
+
+    // 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.statistics();
+  cout << nCharge << spheri << linea << thrust << oblateness 
+       << sAxis << lAxis << tAxis
+       << nLund << nJade << nDurham
+       << eDifLund << eDifJade << eDifDurham; 
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main10.cc b/PYTHIA8/pythia8145/examples/main10.cc
new file mode 100644 (file)
index 0000000..3e72882
--- /dev/null
@@ -0,0 +1,157 @@
+// main10.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// 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 cone-jet finder with (etaMax, nEta, nPhi).
+  MyUserHooks() { coneJet = new CellJet(5., 100, 64); }
+
+  // Destructor deletes cone-jet finder.
+  ~MyUserHooks() {delete coneJet;}
+
+  // 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 eTjet > 10 for R = 0.7.
+    coneJet->analyze(event, 10., 0.7);
+    int nJet = coneJet->size();      
+    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 cone-jet finder.
+  CellJet* coneJet;
+
+  // 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.init( 2212, -2212, 1960.);
+   
+  // Begin event loop.
+  for (int iEvent = 0; iEvent < 1000; ++iEvent) {
+
+    // Generate events. 
+    pythia.next();
+
+  // End of event loop.
+  }
+
+  // Statistics. Histograms.
+  pythia.statistics();
+  cout << pTtrial << pTselect << pTaccept 
+       << nPartonsB << nJets << nPartonsA 
+       << nFSRatISR;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main11.cc b/PYTHIA8/pythia8145/examples/main11.cc
new file mode 100644 (file)
index 0000000..030c0ef
--- /dev/null
@@ -0,0 +1,92 @@
+// main11.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Generate a predetermined second hard interaction.
+
+#include "Pythia.h"
+
+using namespace Pythia8;
+int main() {
+
+  // Generator. 
+  Pythia pythia;
+  Event& process = pythia.process;
+  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.
+  pythia.init( 2212, 2212, 14000.);
+
+  // Show changed settings.
+  pythia.settings.listChanged();
+
+  // Histogram.
+  Hist pTfirst("pT first collision",    100, 0., 200.);
+  Hist pTsecond("pT second collision",  100, 0., 200.);
+  Hist pTdiff("pT first-second collision", 100, -100., 100.);
+  Hist nMult("number of multiple 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. List first few.
+  for (int iev = 0; iev < 200; ++iev) {
+    pythia.next();
+    if (iev < 1) {
+      pythia.info.list();
+      process.list();
+      event.list();
+    }
+
+    // Histogram pT.
+    double pT1 = pythia.info.pTMI(0);
+    double pT2 = pythia.info.pTMI(1);
+    pTfirst.fill( pT1 );
+    pTsecond.fill( pT2 );
+    pTdiff.fill( pT1 - pT2 );
+
+    // Histogram multiple interactions
+    double nMI = pythia.info.nMI();
+    nMult.fill( nMI );
+    bMore.fill( pythia.info.enhanceMI() );
+
+    // 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.statistics();
+  cout << scientific << setprecision(3) << " 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/pythia8145/examples/main12.cc b/PYTHIA8/pythia8145/examples/main12.cc
new file mode 100644 (file)
index 0000000..432fa67
--- /dev/null
@@ -0,0 +1,83 @@
+// main12.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This 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.
+// Other samples could be generated as illustrated by main53.f.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+
+  // Number of events to print.
+  int nPrint = 1;             
+
+  // Generator           
+  Pythia pythia;                            
+
+  // Stick with default values, so do not bother with a separate file
+  // for changes. However, do one change, to show readString in action.
+  pythia.readString("PartonLevel:MI = off"); 
+
+  // Initialize Les Houches Event File run. List initialization information.
+  pythia.init("ttbar.lhe");      
+
+  // Book histogram.
+  Hist nCharged("charged particle multiplicity",100,-0.5,399.5); 
+  Hist thetaRatio("ratio of two cos(theta) calculations",100,0.5,1.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;
+    }
+  
+    // List first few events: Les Houches, hard process and complete.
+    if (iEvent < nPrint) {     
+      pythia.LHAeventList();               
+      pythia.info.list();          
+      pythia.process.list();          
+      pythia.event.list();           
+    }                           
+
+    // 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);               
+
+    // Compare cos(theta) = (tHat - uHat) / (beta_34 * sHat);
+    double cosThe1 = cos(pythia.info.thetaHat());
+    double sH = pythia.info.sHat();    
+    double m3S = pow2( pythia.info.m3Hat() ); 
+    double m4S = pow2( pythia.info.m4Hat() ); 
+    double sHcorr = sqrt( pow2(sH - m3S - m4S) - 4. * m3S * m4S);
+    double cosThe2 = (pythia.info.tHat() - pythia.info.uHat()) / sHcorr;
+    thetaRatio.fill(cosThe2 / cosThe1);
+
+  // End of event loop.        
+  }                                           
+
+  // Give statistics. Print histogram.
+  pythia.statistics();
+  cout << nCharged << thetaRatio;  
+
+  // Done.                           
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main13.cc b/PYTHIA8/pythia8145/examples/main13.cc
new file mode 100644 (file)
index 0000000..4e7002c
--- /dev/null
@@ -0,0 +1,107 @@
+// main13.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This 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 in
+// the event generation by a pythia.init( fileName, true) call.
+// 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, as it would have been without "true".
+// 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 events to print: LHA and others.
+  int nPrintLHA  = 1;             
+  int nPrintRest = 1;             
+
+  // Allow for possibility of a few faulty events.
+  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.");    
+
+  // Initialize Les Houches Event File run. List initialization information.
+  pythia.init("ttbar.lhe");   
+
+  // List changed settings and particle data.
+  pythia.settings.listChanged();   
+  pythia.particleData.listChanged();   
+
+  // 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.init("ttbar2.lhe", true);   
+          ++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.statistics();
+  cout << nCharged;  
+
+  // Done.                           
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main14.cc b/PYTHIA8/pythia8145/examples/main14.cc
new file mode 100644 (file)
index 0000000..00146bc
--- /dev/null
@@ -0,0 +1,162 @@
+// main14.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// 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: can run from 0 through 40.
+  int iFirst = 0;
+  int iLast  = 56;   
+
+  // Statistics. Pythia6 run was with 10000, so no point to use more.
+  int nEvent = 10000; 
+
+  // Normally one subprocess word per subrun, but exceptions exist. 
+  int nSub[100];
+  for (int i = 0; i < 100; ++i) nSub[i] = 1; 
+  nSub[1] = 3;  
+  nSub[5] = 3;  
+  // Starting positions in subprocess words list, recursively defined.
+  int iBeg[101] = { 0 };
+  for (int i = 0; i < 100; ++i) iBeg[i + 1] = iBeg[i] + nSub[i]; 
+  // List of subprocess words. 
+  string processes[61] = { "HardQCD:gg2gg", "HardQCD:gg2qqbar",
+    "HardQCD:gg2ccbar",  "HardQCD:gg2bbbar","HardQCD:qg2qg" , 
+    "HardQCD:qq2qq", "HardQCD:qqbar2gg", "HardQCD:qqbar2qqbarNew", 
+    "HardQCD:qqbar2ccbar", "HardQCD:qqbar2bbbar", "PromptPhoton:qg2qgamma",
+    "PromptPhoton:qqbar2ggamma", "PromptPhoton:gg2ggamma", 
+    "PromptPhoton:ffbar2gammagamma", "PromptPhoton:gg2gammagamma",
+    "WeakBosonExchange:ff2ff(t:gmZ)", "WeakBosonExchange:ff2ff(t:W)",
+    "WeakSingleBoson:ffbar2gmZ", "WeakSingleBoson:ffbar2W", 
+    "WeakDoubleBoson:ffbar2gmZgmZ", "WeakDoubleBoson:ffbar2ZW",
+    "WeakDoubleBoson:ffbar2WW", "WeakBosonAndParton:qqbar2gmZg",
+    "WeakBosonAndParton:qg2gmZq", "WeakBosonAndParton:ffbar2gmZgm",
+    "WeakBosonAndParton:qqbar2Wg", "WeakBosonAndParton:qg2Wq",
+    "WeakBosonAndParton:ffbar2Wgm", "Charmonium:all", "Bottomonium:all",
+    "Top:gg2ttbar",  "Top:qqbar2ttbar",  "Top:qq2tq(t:W)",    
+    "Top:ffbar2ttbar(s:gmZ)", "Top:ffbar2tqbar(s:W)",
+    "HiggsSM:ffbar2H", "HiggsSM:gg2H", "HiggsSM:ffbar2HZ", 
+    "HiggsSM:ffbar2HW", "HiggsSM:ff2Hff(t:ZZ)", "HiggsSM:ff2Hff(t:WW)",
+    "HiggsSM:qg2Hq", "HiggsSM:gg2Hg(l:t)", "HiggsSM:qg2Hq(l:t)", 
+    "HiggsSM:qqbar2Hg(l:t)", "HiggsBSM:allH1", "HiggsBSM:allH2",
+    "HiggsBSM:allA3", "HiggsBSM:allH+-", "HiggsBSM:allHpair",
+    "NewGaugeBoson:ffbar2gmZZprime", "NewGaugeBoson:ffbar2Wprime",
+    "LeftRightSymmmetry:ffbar2ZR", "LeftRightSymmmetry:ffbar2WR", 
+    "LeftRightSymmmetry:ffbar2HLHL", "LeftRightSymmmetry:ffbar2HRHR", 
+    "LeptoQuark:all", "ExcitedFermion:dg2dStar", 
+    "ExcitedFermion:qq2dStarq", "ExcitedFermion:qqbar2eStare",
+    "ExtraDimensionsG*:all" }; 
+
+  // List of cross sections from Pythia6.
+  double sigma6[57] = {   4.960e-01, 1.627e-02, 2.790e-01, 2.800e-02, 
+    3.310e-04, 3.653e-04, 1.697e-04, 1.163e-05, 1.065e-07, 8.259e-08, 
+    8.237e-08, 2.544e-05, 5.321e-06, 5.571e-05, 1.621e-04, 9.039e-09,
+    2.247e-08, 5.893e-08, 3.781e-06, 1.078e-05, 4.551e-08, 1.025e-05,
+    3.208e-05, 5.435e-08, 1.038e-04, 3.929e-05, 4.155e-07, 6.685e-08,
+    1.898e-07, 4.240e-10, 7.142e-09, 1.547e-10, 7.064e-09, 1.316e-10,
+    2.332e-10, 5.105e-10, 1.316e-09, 4.462e-11, 5.557e-09, 1.966e-09,
+    8.725e-12, 2.450e-08, 5.839e-09, 1.687e-08, 8.950e-11, 4.188e-11,
+    1.980e-07, 4.551e-07, 6.005e-09, 1.102e-07, 7.784e-11, 3.488e-11, 
+    6.006e-08, 3.235e-06, 1.689e-05, 5.986e-07, 3.241e-10 };
+
+  // Generator. 
+  Pythia pythia;
+
+  // Standard set of masses for comparison with Fortran code.
+  pythia.readString("5:m0  = 4.2");
+  pythia.readString("6:m0  = 175.");
+  pythia.readString("23:m0 = 91.2");
+  pythia.readString("24:m0 = 80.");
+
+  // Same kinematics cuts as Fortran code.
+  pythia.readString("PhaseSpace:pTHatMin = 20.");
+  pythia.readString("6:mMin = 20.");
+  pythia.readString("23:mMin = 20.");
+  pythia.readString("24:mMin = 20.");
+  pythia.readString("25:mMin = 20.");
+  pythia.readString("32:mMin = 400.");
+  pythia.readString("34:mMin = 400.");
+  pythia.readString("42:mMin = 50.");
+  pythia.readString("5000039:mMin = 50.");
+
+  // Also same renormalization and factorization scale.
+  pythia.readString("SigmaProcess:renormScale2 = 3");
+  pythia.readString("SigmaProcess:factorScale2 = 3");
+
+  // Switch off unnecessary parts.
+  pythia.readString("PartonLevel:all = off");
+
+  // Debug: show information on cross section maximum and violation.
+  //pythia.readString("PhaseSpace:showSearch = on");
+  //pythia.readString("PhaseSpace:showViolation = on");
+
+  // Loop over processes.
+  for (int iProc = iFirst; iProc <= iLast; ++iProc) {
+    cout << "\n Begin subrun number " << iProc << endl;
+
+    // Switch off previous process(es) and switch on new one(s).
+    if (iProc > iFirst) for (int i = iBeg[iProc - 1]; i < iBeg[iProc]; ++i) 
+      pythia.readString( processes[i] + " = off" );
+    for (int i = iBeg[iProc]; i < iBeg[iProc + 1]; ++i)
+      pythia.readString( processes[i] + " = on" );
+
+    // Switch between SM and MSSM Higgs scenario.
+    if (iProc <= 40) {
+      pythia.readString("Higgs:useBSM = off");
+      pythia.readString("25:m0 = 200.");
+    } else {
+      pythia.readString("Higgs:useBSM = on");
+      pythia.readString("25:m0 = 115.");
+      pythia.readString("35:m0 = 300.");
+      pythia.readString("36:m0 = 300.");
+      pythia.readString("37:m0 = 320.");
+    }  
+
+    // Initialize for LHC.
+    pythia.init( 2212, 2212, 14000.);
+
+    // Debug: show initialized resonance data first time around.
+    //if (iProc == iFirst) pythia.particleData.listChanged(true);
+
+    // Generate events to get cross section statistics.
+    for (int iEvent = 0; iEvent < nEvent; ++iEvent) pythia.next();
+    // Show statistics.
+    //pythia.statistics();
+    double sigma = pythia.info.sigmaGen();
+    cout << " Cross section is " << scientific << setprecision(3)  
+         << sigma << " and in Pythia6 was " << sigma6[iProc] 
+         << ",\n i.e. now is factor >>> " << fixed 
+         << sigma / sigma6[iProc] << " <<< different" <<endl;
+
+  // End of loop over processes.
+  }
+
+  // Done. 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main15.cc b/PYTHIA8/pythia8145/examples/main15.cc
new file mode 100644 (file)
index 0000000..c551ab1
--- /dev/null
@@ -0,0 +1,207 @@
+// main15.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how either
+// (a) B decays (sections marked "Repeated decays:), or 
+// (b) all hadronization (sections marked "Repeated hadronization:")
+// could be repeated a number of times for each event,
+// to improve statistics when this could be a problem.
+// Option (a) is faster than (b), but less generic.
+
+#include "Pythia.h"
+using namespace Pythia8;
+int main() {
+
+  // Main switchs: redo B decays only or redo all hadronization, but not both.  
+  bool redoBDecays = false;
+  bool redoHadrons = true;
+  if (redoHadrons) redoBDecays = false; 
+
+  // Number of events, generated and listed ones.
+  int nEvent = 100;
+  int nList = 1;
+
+  // Number of times decays/hadronization should be redone for each event.
+  int nRepeat = 10; 
+  if (!redoBDecays && !redoHadrons) nRepeat = 1;
+
+  // Generator. Shorthand for event.
+  Pythia pythia;
+  Event& event = pythia.event;
+
+  // Simulate b production above given pTmin scale.
+  // Warning: these processes do not catch all possible production modes.
+  // You would need to use HardQCD:all or even SoftQCD:minBias for that.
+  pythia.readString("HardQCD:gg2bbbar = on");    
+  pythia.readString("HardQCD:qqbar2bbbar = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 50.");  
+
+  // Repeated decays: list of weakly decaying B hadrons.
+  // Note: this list is overkill; some will never be produced.
+  int bCodes[28] = {511, 521, 531, 541, 5122, 5132, 5142, 5232, 5242,
+    5332, 5342, 5412, 5414, 5422, 5424, 5432, 5434, 5442, 5444, 5512,
+    5514, 5522, 5524, 5532, 5534, 5542, 5544, 5544 }; 
+  int nCodes = 28;
+
+  // Repeated decays: location of B handrons.
+  vector<int> iBHad;
+  int nBHad = 0;
+
+  // Repeated hadronization: spare copy of event.
+  Event savedEvent;  
+
+  // Repeated hadronization: switch off normal HadronLevel call.
+  if (redoHadrons) pythia.readString("HadronLevel:all = off");  
+
+  // Initialize for LHC energies.    
+  pythia.init( 2212, 2212, 14000.);
+
+  // Show changed settings and particleData.
+  pythia.settings.listChanged();
+  pythia.particleData.listChanged();
+
+  // Histogram invariant mass of muon pairs.
+  Hist nBperEvent("number of b quarks in an event", 10, -0.5, 9.5); 
+  Hist nSameEvent("number of times same event is used", 10, -0.5, 9.5); 
+  Hist oppSignMass("mass of opposite-sign muon pair", 100, 0.0, 100.0);
+  Hist sameSignMass("mass of same-sign muon pair", 100, 0.0, 100.0);
+
+  // Begin event loop.
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Repeated decays: switch off decays of weakly decaying B hadrons.
+    // (More compact solution than repeated readString(..).)
+    if (redoBDecays) for (int iC = 0; iC < nCodes; ++iC) 
+      pythia.particleData.mayDecay( bCodes[iC], false);
+
+    // Generate event. Skip it if error.
+    if (!pythia.next()) continue;
+
+    // List first few events.
+    if (iEvent < nList) {
+      pythia.info.list(); 
+      pythia.process.list();
+      event.list();
+    }
+
+    // Find and histogram number of b quarks.
+    int nBquark = 0;
+    int stat;
+    for (int i = 0; i < event.size(); ++i) {
+      stat = event[i].statusAbs();
+      if (event[i].idAbs() == 5 && (stat == 62 || stat == 63)) ++nBquark;
+    }
+    nBperEvent.fill( nBquark ); 
+
+    // Repeated decays: find all locations where B hadrons are stored.
+    if (redoBDecays) {
+      iBHad.resize(0);
+      for (int i = 0; i < event.size(); ++i) {
+        int idAbs = event[i].idAbs();
+        for (int iC = 0; iC < 28; ++iC) 
+        if (idAbs == bCodes[iC]) {       
+          iBHad.push_back(i);
+          break;
+        }
+      }
+
+      // Repeated decays: check that #b = #B.
+      nBHad = iBHad.size();
+      if (nBquark != nBHad) cout << " Warning: " << nBquark 
+        << " b quarks but " << nBHad << " B hadrons" << endl;
+
+      // Repeated decays: store size of current event.
+      event.saveSize();
+
+      // Repeated decays: switch back on weakly decaying B hadrons.
+      for (int iC = 0; iC < nCodes; ++iC) 
+        pythia.particleData.mayDecay( bCodes[iC], true);
+    
+    //  Repeated hadronization: copy event into spare position.
+    } else if (redoHadrons) {
+      savedEvent = event;
+    }
+
+    // Begin loop over rounds of decays / hadronization for same event.
+    int nWithPair = 0;
+    for (int iRepeat = 0; iRepeat < nRepeat; ++iRepeat) {
+
+      // Repeated decays: remove B decay products from previous round.
+      if (redoBDecays) {
+        if (iRepeat > 0) {
+          event.restoreSize();
+
+          // Repeated decays: mark decayed B hadrons as undecayed.
+          for (int iB = 0; iB < nBHad; ++iB) event[ iBHad[iB] ].statusPos(); 
+        } 
+  
+        // Repeated decays: do decays of B hadrons, sequentially for products. 
+        // Note: modeDecays does not work for bottomonium (or heavier) states,
+        // since there decays like Upsilon -> g g g also need hadronization.
+        // Also, there is no provision for Bose-Einstein effects.
+        if (!pythia.moreDecays()) continue;
+
+
+      // Repeated hadronization: restore saved event record.
+      } else if (redoHadrons) {
+        if (iRepeat > 0) event = savedEvent;
+  
+        // Repeated hadronization: do HadronLevel (repeatedly).
+        if (!pythia.forceHadronLevel()) continue; 
+      }
+  
+      // List last repetition of first few events.
+      if ( (redoBDecays || redoHadrons) && iEvent < nList 
+        && iRepeat == nRepeat - 1) event.list();
+
+      // Look for muons among decay products (also from charm/tau/...).
+      vector<int> iMuNeg, iMuPos;
+      for (int i = 0; i < event.size(); ++i) {
+        int id = event[i].id();  
+        if (id ==  13) iMuNeg.push_back(i);
+        if (id == -13) iMuPos.push_back(i);
+      }
+      
+      // Check whether pair(s) present.
+      int nMuNeg = iMuNeg.size();
+      int nMuPos = iMuPos.size();
+      if (nMuNeg + nMuPos > 1) {
+        ++nWithPair;
+
+        // Fill masses of opposite-sign pairs.
+        for (int iN = 0; iN < nMuNeg; ++iN)
+        for (int iP = 0; iP < nMuPos; ++iP) 
+          oppSignMass.fill(
+            (event[iMuNeg[iN]].p() + event[iMuPos[iP]].p()).mCalc() );
+
+        // Fill masses of same-sign pairs.
+        for (int i1 = 0; i1 < nMuNeg - 1; ++i1)
+        for (int i2 = i1 + 1; i2 < nMuNeg; ++i2) 
+          sameSignMass.fill(
+            (event[iMuNeg[i1]].p() + event[iMuNeg[i2]].p()).mCalc() );
+        for (int i1 = 0; i1 < nMuPos - 1; ++i1)
+        for (int i2 = i1 + 1; i2 < nMuPos; ++i2) 
+          sameSignMass.fill(
+            (event[iMuPos[i1]].p() + event[iMuPos[i2]].p()).mCalc() );
+
+      // Finished analysis of current round. 
+      }
+
+    // End of loop over many rounds. fill number of rounds with pairs.
+    }
+    nSameEvent.fill( nWithPair );
+
+  // End of event loop.
+  }
+
+  // Statistics. Histograms. 
+  pythia.statistics();
+  cout << nBperEvent << nSameEvent << oppSignMass << sameSignMass << endl;
+
+  // Done. 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main16.cc b/PYTHIA8/pythia8145/examples/main16.cc
new file mode 100644 (file)
index 0000000..ec8d998
--- /dev/null
@@ -0,0 +1,197 @@
+// main16.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates (a) how to collect the analysis code in a separate class
+// and (b) how to provide the .cmnd filename on the command line
+
+// Once you have linked the main program you can run it with a command line
+// ./main16.exe main16.cmnd > out16
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+// Put all your own analysis code in the myAnalysis class. 
+
+class MyAnalysis {
+
+public:
+
+  // Constructor can be empty.
+  MyAnalysis() {}
+
+  // Initialization actions.
+  void init();
+  // Analysis of each new event.
+  void analyze(Event& event);
+
+  // Show final results.
+  void finish();
+
+private:
+
+  // Declare variables and objects that span init - analyze - finish.
+  int  nEvt;
+  Hist yH, etaChg, mult; 
+
+};
+
+//--------------------------------------------------------------------------
+
+// The initialization code. 
+
+void MyAnalysis::init() {
+
+  // Initialize counter for number of events.
+  nEvt = 0;
+
+  // Book histograms.
+  yH.book("Higgs rapidity", 100, -10., 10.);
+  etaChg.book("charged pseudorapidity", 100, -10., 10.);
+  mult.book( "charged multiplicity", 100, -0.5, 799.5);
+
+} 
+
+//--------------------------------------------------------------------------
+
+// The event analysis code. 
+
+void MyAnalysis::analyze(Event& event) {
+
+  // Increase counter.
+  ++nEvt;
+
+  // Find latest copy of Higgs and plot its rapidity.
+  int iH = 0;
+  for (int i = 0; i < event.size(); ++i) 
+    if (event[i].id() == 25) iH = i;
+  yH.fill( event[iH].y() );
+
+  // Plot pseudorapidity distribution. Sum up charged multiplicity.
+  int nChg = 0;
+  for (int i = 0; i < event.size(); ++i) 
+  if (event[i].isFinal() && event[i].isCharged()) {
+    etaChg.fill( event[i].eta() );
+    ++nChg;
+  }
+  mult.fill( nChg );
+
+} 
+
+//--------------------------------------------------------------------------
+
+// The finishing code. 
+
+void MyAnalysis::finish() {
+
+  // Normalize histograms.
+  double binFactor = 5. / nEvt;
+  yH     *= binFactor;
+  etaChg *= binFactor;
+
+  // Print histograms.
+  cout << yH << etaChg << mult;
+
+} 
+
+//==========================================================================
+
+// You should not need to touch the main program: its actions are 
+// determined by the .cmnd file and the rest belongs in MyAnalysis.
+
+int main(int argc, char* argv[]) {
+
+  // Check that correct number of command-line arguments
+  if (argc != 2) {
+    cerr << " Unexpected number of command-line arguments. \n"
+         << " You are expected to provide a file name and nothing else. \n"
+         << " Program stopped! " << endl;
+    return 1;
+  }
+
+  // Check that the provided file name corresponds to an existing file.
+  ifstream is(argv[1]);  
+  if (!is) {
+    cerr << " Command-line file " << argv[1] << " was not found. \n"
+         << " Program stopped! " << endl;
+    return 1;
+  }
+
+  // Confirm that external file will be used for settings..
+  cout << " PYTHIA settings will be read from file " << argv[1] << endl;
+
+  // Declare generator. Read in commands from external file.
+  Pythia pythia;
+  pythia.readFile(argv[1]);
+
+  // Extract settings to be used in the main program.
+  int    nEvent    = pythia.mode("Main:numberOfEvents");
+  int    nList     = pythia.mode("Main:numberToList");
+  int    nShow     = pythia.mode("Main:timesToShow");
+  int    nAbort    = pythia.mode("Main:timesAllowErrors");
+  bool   showCS    = pythia.flag("Main:showChangedSettings");
+  bool   showAS    = pythia.flag("Main:showAllSettings");
+  int    showOne   = pythia.mode("Main:showOneParticleData");
+  bool   showCPD   = pythia.flag("Main:showChangedParticleData");
+  bool   showCRD   = pythia.flag("Main:showChangedResonanceData");
+  bool   showAPD   = pythia.flag("Main:showAllParticleData");
+  bool   showAStat = pythia.flag("Main:showAllStatistics");
+  // Initialization with no arguments means that the Beams settings are used.
+  pythia.init();
+
+  // List changed data.
+  if (showCS) pythia.settings.listChanged();
+  if (showAS) pythia.settings.listAll();
+
+  // List particle data.  
+  if (showOne > 0) pythia.particleData.list(showOne);
+  if (showCPD) pythia.particleData.listChanged(showCRD);
+  if (showAPD) pythia.particleData.listAll();
+
+  // Declare user analysis class. Do initialization part of it.
+  MyAnalysis myAnalysis;
+  myAnalysis.init(); 
+
+  // Begin event loop. Show how far the run has progressed.
+  int nPace = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0; 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if too many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both hard process and complete events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+    // User Analysis of current event.
+    myAnalysis.analyze( pythia.event);
+
+  // End of event loop.
+  }
+
+  // Final statistics.
+  pythia.statistics(showAStat);
+
+  // User finishing.
+  myAnalysis.finish();
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main16.cmnd b/PYTHIA8/pythia8145/examples/main16.cmnd
new file mode 100644 (file)
index 0000000..e43d471
--- /dev/null
@@ -0,0 +1,38 @@
+! File: main16.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) Beam settings.
+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, LHC
+
+! 2) Settings that are used in the main program.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is this many times
+Main:timesAllowErrors = 10         ! abort run after this many flawed events
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+#Main:showAllSettings = on          ! print all flags/modes/parameters
+Main:showOneParticleData = 25      ! print data for this particular particle
+Main:showChangedParticleData = on  ! print changed particle and decay data
+#Main:showChangedResonanceData = on ! also print changed resonance data
+#Main:showAllParticleData = on      ! print all particle and decay data
+Main:showAllStatistics = on        ! more statistics on multiple interactions
+
+! 3) Settings for hard-process generation internal to Pythia8.
+HiggsSM:gg2H = on                  ! Higgs production by gluon-gluon fusion
+25:m0 = 123.5                      ! Higgs mass
+
+! 4) Switch off some key components of the simulation, for comparisons.
+#PartonLevel:all = off              ! stop after hard process 
+#PartonLevel:MI = off               ! no multiple interactions
+#PartonLevel:ISR = off              ! no initial-state radiation 
+#PartonLevel:FSR = off              ! no final-state radiation
+#HadronLevel:all = off              ! stop after parton level 
+#HadronLevel:Hadronize = off        ! no hadronization
+#HadronLevel:Decay = off            ! no decays
+
+! 5) Any other changes you desire.
diff --git a/PYTHIA8/pythia8145/examples/main17.cc b/PYTHIA8/pythia8145/examples/main17.cc
new file mode 100644 (file)
index 0000000..5ed9058
--- /dev/null
@@ -0,0 +1,217 @@
+// main17.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates (a) how to collect most of the interaction with Pythia,
+// in a separate class, with actions mostly dictated by a .cmnd file,
+// and (b) how to provide the .cmnd filename on the command line
+
+// Once you have linked the main program you can run it with a command line
+// ./main17.exe main17.cmnd > out17
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+// Put most of your Pythia interaction in the PythiaWrapper class.
+// Note: this way you restrict yourself to a subset of the full Pythia
+// functionality, for better or worse.
+
+class PythiaWrapper {
+
+public:
+
+  // Constructor can be empty.
+  PythiaWrapper() {}
+
+  // Initialization actions: pythia.init() and more.
+  // Input from command-line arguments of main program.
+  bool beg(int argc, char* argv[]);
+  // Event generation actions: pythia.next() and more.
+  bool gen();
+
+  // Final actions: statistics.
+  bool fin();
+
+  // Provide number of events to generate.
+  int  nEvt() const {return nEvent;}
+
+  // Restricted access to the pythia.event event record.
+  int  size() const {return pythia.event.size();}
+  const Particle& operator[](int i) const {return pythia.event[i];}
+
+private:
+
+  // The Pythia class that does the job.
+  Pythia pythia;
+
+  // Various quantities read in at the beginning and used later.
+  int nEvent, nList, nShow, nAbort, nPace, iEvent, iList, iAbort;
+
+};
+
+//--------------------------------------------------------------------------
+
+// The initialization code. 
+
+bool PythiaWrapper::beg(int argc, char* argv[]) {
+
+  // Check that correct number of command-line arguments
+  if (argc != 2) {
+    cerr << " Unexpected number of command-line arguments. \n"
+         << " You are expected to provide a file name and nothing else. \n"
+         << " Program stopped! " << endl;
+    return false;
+  }
+
+  // Check that the provided file name corresponds to an existing file.
+  ifstream is(argv[1]);  
+  if (!is) {
+    cerr << " Command-line file " << argv[1] << " was not found. \n"
+         << " Program stopped! " << endl;
+    return false;
+  }
+
+  // Confirm that external file will be used for settings..
+  cout << " PYTHIA settings will be read from file " << argv[1] << endl;
+
+  // Read in the cards file with Pythia commands.
+  pythia.readFile(argv[1]);
+  // Initialization, using the Beams settings. Give up if failure.
+  if ( !pythia.init() ) return false;
+
+  // Shorthand for pythia.settings and pythia.particleData.
+  Settings&     pSet = pythia.settings;
+  ParticleData& pDat = pythia.particleData;
+
+  // List settings: changed or all.
+  if ( pSet.flag("Main:showChangedSettings") )  pSet.listChanged();
+  if ( pSet.flag("Main:showAllSettings") ) pSet.listAll();
+
+  // List particle data; one special, changed (with resonances?), or all.  
+  if ( pSet.mode("Main:showOneParticleData") > 0 ) 
+    pDat.list( pSet.mode("Main:showOneParticleData") );
+  if ( pSet.flag("Main:showChangedParticleData") ) 
+    pDat.listChanged( pSet.flag("Main:showChangedResonanceData") );
+  if ( pSet.flag("Main:showAllParticleData") ) pDat.listAll();
+
+  // Extract settings to be used in event generation loop.
+  nEvent = pSet.mode("Main:numberOfEvents");
+  nList  = pSet.mode("Main:numberToList");
+  nShow  = pSet.mode("Main:timesToShow");
+  nAbort = pSet.mode("Main:timesAllowErrors");
+
+  // Initialize counters to use in event generation loop.
+  nPace  = max(1, nEvent / max(1, nShow) ); 
+  iEvent = 0;
+  iList  = 0;
+  iAbort = 0; 
+
+  // Done.
+  return true;
+
+} 
+
+//--------------------------------------------------------------------------
+
+// The event generation code. 
+
+bool PythiaWrapper::gen() {
+
+  // Handle occasional abort by internal loop.
+  for( ;  ;  ) { 
+
+    // At times print line with progress report. Count up event number.
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+    ++iEvent; 
+
+    // Generate events, and check whether generation failed.
+    if ( !pythia.next() ) {
+
+      // If failure because reached end of file then quit.
+      if ( pythia.info.atEndOfFile() ) return false; 
+
+      // First few failures write off as "acceptable" errors, then quit.
+      if ( ++iAbort <= nAbort ) continue;
+      return false;
+    }
+
+    // End of internal loop - valid event generated.
+    break;
+  }
+  // List first few events, both hard process and complete events.
+  if ( ++iList <= nList ) { 
+    pythia.info.list();
+    pythia.process.list();
+    pythia.event.list();
+  }
+
+  // Done.
+  return true;
+
+} 
+
+//--------------------------------------------------------------------------
+
+// The finishing code. 
+
+bool PythiaWrapper::fin() {
+
+  // Final statistics.
+  pythia.statistics( pythia.settings.flag("Main:showAllStatistics") );
+
+  // Done.
+  return true;
+
+} 
+
+//==========================================================================
+
+// You should not need to touch the main program: its actions are 
+// determined by the .cmnd file and the rest belongs in MyAnalysis.
+
+int main(int argc, char* argv[]) {
+
+  // Declare generator.
+  PythiaWrapper pWrap;
+
+  // Initialize it with command-line arguments. Done if fail.
+  if ( !pWrap.beg(argc, argv) ) return 1;
+
+  // Book histograms.
+  Hist ZPmass("mass of gamma*/Z0/Z' state", 100, 0., 2000.);
+  Hist ZPpT("pT of gamma*/Z0/Z' state", 100, 0., 500.);    
+
+  // Begin of event loop. 
+  int nEvent = pWrap.nEvt();
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Generate event. Quit if returns false.
+    if ( !pWrap.gen() ) break;
+
+    // Find the last copy of Z', i.e. after cascades, just before decay.
+    int iZP = 0;
+    for (int i = 0; i < pWrap.size(); ++i) if (pWrap[i].id() == 32) iZP = i;
+
+    // Histogram its mass and pT.
+    ZPmass.fill( pWrap[iZP].m() );
+    ZPpT.fill( pWrap[iZP].pT() );
+
+  // End of event loop.
+  }
+
+  // Final statistics and histograms.
+  pWrap.fin();
+  cout << ZPmass << ZPpT;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main17.cmnd b/PYTHIA8/pythia8145/examples/main17.cmnd
new file mode 100644 (file)
index 0000000..5cf858c
--- /dev/null
@@ -0,0 +1,39 @@
+! File: main17.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) Beam settings.
+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, LHC
+
+! 2) Settings that are used in the main program.
+Main:numberOfEvents = 1000         ! number of events to generate
+Main:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is this many times
+Main:timesAllowErrors = 10         ! abort run after this many flawed events
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+#Main:showAllSettings = on          ! print all flags/modes/parameters
+Main:showOneParticleData = 32      ! print data for this particular particle
+Main:showChangedParticleData = on  ! print changed particle and decay data
+#Main:showChangedResonanceData = on ! also print changed resonance data
+#Main:showAllParticleData = on      ! print all particle and decay data
+#Main:showAllStatistics = on        ! more statistics on multiple interactions
+
+! 3) Settings for hard-process generation internal to Pythia8.
+NewGaugeBoson:ffbar2gmZZprime = on ! full gamma*/Z^0/Z'^0 production
+32:m0 = 1000.                      ! Z' mass
+32:mMin = 200.                     ! cut off gamma*/Z^0 peaks 
+
+! 4) Switch off some key components of the simulation, for comparisons.
+#PartonLevel:all = off              ! stop after hard process 
+#PartonLevel:MI = off               ! no multiple interactions
+#PartonLevel:ISR = off              ! no initial-state radiation 
+#PartonLevel:FSR = off              ! no final-state radiation
+HadronLevel:all = off              ! stop after parton level 
+#HadronLevel:Hadronize = off        ! no hadronization
+#HadronLevel:Decay = off            ! no decays
+
+! 5) Any other changes you desire.
diff --git a/PYTHIA8/pythia8145/examples/main18.cc b/PYTHIA8/pythia8145/examples/main18.cc
new file mode 100644 (file)
index 0000000..0da2af4
--- /dev/null
@@ -0,0 +1,229 @@
+// main18.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how to write an event filter.
+// No new functionality is involved - all could be done in the main program 
+// - but the division of tasks may be more convenient for recurrent cuts.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+// The EventFilter class. 
+
+// The constructor takes the following arguments 
+// select = 1 : keep only final particles.
+//        = 2 : keep only final visible particles (i.e. not neutrinos).
+//        = 3 : keep only final charged particles.
+// etaMax (default = 50) : keep only particles with pseudorapidity
+//        |eta| < etaMax.
+// pTminCharged (default = 0) : keep a charged particle only if
+//        its transverse momentum pT < pTminCharged.
+// pTminNeutral (default = 0) : keep a neutral particle only if
+//        its transverse momentum pT < pTminNeutral.
+
+// Main methods:
+// filter( event) takes an event record as input and analyzes it.
+// size() returns the number of particles kept.
+// index(i) returns the index in the full event of the i'th kept particle. 
+// particlePtr(i) returns a pointer to the i'th kept particle. 
+// particleRef(i) returns a reference to the i'th kept particle. 
+// list() gives a listing of the kept particles only.
+        
+class EventFilter {
+
+public:
+
+  // Constructor sets properties of filter..
+  EventFilter( int selectIn, double etaMaxIn = 50., 
+    double pTminChargedIn = 0., double pTminNeutralIn = 0.) 
+    : select(selectIn), etaMax(etaMaxIn), pTminCharged(pTminChargedIn),
+    pTminNeutral(pTminNeutralIn) {}
+  // Analysis of each new event to find acceptable particles.
+  void filter(Event& event);
+
+  // Return size of array, and index of a particle.
+  int size()       const {return keptPtrs.size();}
+  int index(int i) const {return keptIndx[i];}
+
+  // Return pointer or reference to a particle.
+  Particle* particlePtr(int i) {return  keptPtrs[i];}
+  Particle& particleRef(int i) {return *keptPtrs[i];}
+
+  // List kept particles only.
+  void list(ostream& os = cout);  
+
+private:
+
+  // Filter properties, set by constructor.
+  int    select;
+  double etaMax, pTminCharged, pTminNeutral;
+
+  // Kept particle indices and pointers, referring to original event.
+  vector<int>       keptIndx;
+  vector<Particle*> keptPtrs;
+
+};
+
+//--------------------------------------------------------------------------
+
+// The filter method. 
+
+void EventFilter::filter(Event& event) {
+
+  // Reset arrays in preparation for new event.
+  keptIndx.resize(0);
+  keptPtrs.resize(0);
+  
+  // Loop over all particles in the event record.
+  for (int i = 0; i < event.size(); ++i) {
+
+    // Skip if particle kind selection criteria not fulfilled.
+    if (!event[i].isFinal()) continue;
+    if (select == 2 && !event[i].isVisible()) continue;
+    bool isCharged = event[i].isCharged();
+    if (select == 3 && !isCharged) continue;
+
+    // Skip if too large pseudorapidity.
+    if (abs(event[i].eta()) > etaMax) continue; 
+
+    // Skip if too small pT.
+    if       (isCharged && event[i].pT() < pTminCharged) continue;
+    else if (!isCharged && event[i].pT() < pTminNeutral) continue;
+
+    // Add particle to vectors of indices and pointers.
+    keptIndx.push_back( i );
+    keptPtrs.push_back( &event[i] );
+
+  // End of particle loop. Done.
+  }
+
+} 
+
+//--------------------------------------------------------------------------
+
+// The list method: downscaled version of Event::list. 
+
+void EventFilter::list(ostream& os) {
+
+  // Header.
+  os << "\n --------  PYTHIA Event Listing  (filtered)  ------------------"
+     << "-----------------------------------------------------------------"
+     << "---- \n \n    no        id   name            status     mothers  "
+     << " daughters     colours      p_x        p_y        p_z         e  "
+     << "        m \n";
+
+  // At high energy switch to scientific format for momenta.
+  double eSum = 0.;
+  for (int iKept = 0; iKept < size(); ++iKept) eSum += keptPtrs[iKept]->e();
+  bool useFixed = (eSum < 1e5);
+
+  // Listing of kept particles in event.
+  for (int iKept = 0; iKept < size(); ++iKept) {
+    int i = keptIndx[iKept]; 
+    Particle& pt = *keptPtrs[iKept];
+
+    // Basic line for a particle, always printed.
+    os << setw(6) << i << setw(10) << pt.id() << "   " << left 
+       << setw(18) << pt.nameWithStatus(18) << right << setw(4) 
+       << pt.status() << setw(6) << pt.mother1() << setw(6) 
+       << pt.mother2() << setw(6) << pt.daughter1() << setw(6) 
+       << pt.daughter2() << setw(6) << pt.col() << setw(6) << pt.acol()
+       << ( (useFixed) ? fixed : scientific ) << setprecision(3) 
+       << setw(11) << pt.px() << setw(11) << pt.py() << setw(11) 
+       << pt.pz() << setw(11) << pt.e() << setw(11) << pt.m() << "\n";
+  }
+
+  // Listing finished.
+  os << "\n --------  End PYTHIA Event Listing  ----------------------------"
+     << "-------------------------------------------------------------------"
+     << endl;
+}
+
+
+//==========================================================================
+
+// Use the EventFilter method to plot some event properties.
+
+int main() {
+
+  // Number of events to generate, to list, to allow aborts.
+  int    nEvent   = 100;
+  int    nList    = 1;
+  int    nAbort   = 3;
+
+  // Declare generator.
+  Pythia pythia;
+
+  // Hard QCD events with pThat > 100.
+  pythia.readString("HardQCD:all = on");
+  pythia.readString("PhaseSpace:pTHatMin = 100.");
+   
+  // Initialization for LHC.
+  pythia.init(2212, 2212, 14000.);
+
+  // List changed settings and particle data.
+  pythia.settings.listChanged();
+  pythia.particleData.listChanged();
+
+  // Values for filter. 
+  int    select   = 3; 
+  double etaMax   = 3.; 
+  double pTminChg = 1.;
+
+  // Declare Event Filter according to specification.
+  EventFilter filter( select, etaMax, pTminChg);
+
+  // Histograms.
+  Hist nCharged(   "selected charged multiplicity",     100, -0.5, 199.5);
+  Hist etaCharged( "selected charged eta distribution", 100, -5.0, 5.0);
+  Hist pTCharged(  "selected charged pT distribution",  100,  0.0, 50.0);
+
+  // 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;
+    }
+
+    // Find final charged particles with |eta| < 3 and pT > 1 GeV.
+    filter.filter( pythia.event); 
+    // List first few events, both complete and after filtering.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      pythia.event.list();
+      filter.list();
+    }
+
+    // Analyze selected particle sample. 
+    nCharged.fill( filter.size() );
+    for (int i = 0; i < filter.size(); ++i) {
+      // Use both reference and pointer notation to illustrate freedom.
+      etaCharged.fill( filter.particleRef(i).eta() );
+      pTCharged.fill(  filter.particlePtr(i)->pT() );
+    }
+    
+  // End of event loop.
+  }
+
+  // Final statistics.
+  pythia.statistics();
+
+  // Histograms.
+  cout << nCharged << etaCharged << pTCharged;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main19.cc b/PYTHIA8/pythia8145/examples/main19.cc
new file mode 100644 (file)
index 0000000..e346cb9
--- /dev/null
@@ -0,0 +1,175 @@
+// main19.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This program runs four instances of Pythia simultaneously,
+// one for signal events, one for pileup background ones, and two
+// For beam-gas background ones. Note that Pythia does not do nuclear
+// effects, so beam-gas is represented by "fixed-target" pp collisions.
+// The = and += overloaded operators are used to join several 
+// event records into one, but should be used with caution.
+
+// Note that each instance of Pythia is independent of any other,
+// but with two important points to remember.
+// 1) By default all generate the same random number sequence,
+//    which has to be corrected if they are to generate the same
+//    physics, like the two beam-gas ones below.
+// 2) Interfaces to external Fortran programs are "by definition" static.
+//    Thus it is not a good idea to use LHAPDF to set different PDF's
+//    in different instances.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+
+//==========================================================================
+
+// Method to pick a number according to a Poissonian distribution.
+
+int poisson(double nAvg, Rndm& rndm) {
+
+  // Set maximum to avoid overflow.
+  const int NMAX = 100;
+
+  // Random number.
+  double rPoisson = rndm.flat() * exp(nAvg);
+
+  // Initialize.
+  double rSum  = 0.;
+  double rTerm = 1.;
+  
+  // Add to sum and check whether done.
+  for (int i = 0; i < NMAX; ) {
+    rSum += rTerm;
+    if (rSum > rPoisson) return i;
+
+    // Evaluate next term. 
+    ++i;
+    rTerm *= nAvg / i;
+  }
+
+  // Emergency return.
+  return NMAX; 
+}
+
+//==========================================================================
+
+int main() {
+
+  // Number of signal events to generate.
+  int nEvent = 100;
+
+  // Beam Energy.
+  double eBeam = 7000.; 
+
+  // Average number of pileup events per signal event.
+  double nPileupAvg = 2.5;
+
+  // Average number of beam-gas events per signal ones, on two sides.
+  double nBeamAGasAvg = 0.5;
+  double nBeamBGasAvg = 0.5;
+
+  // Four generator instances.
+  Pythia pythiaSignal;
+  Pythia pythiaPileup;
+  Pythia pythiaBeamAGas;
+  Pythia pythiaBeamBGas;
+
+  // One object where all individual events are to be collected.
+  Event sumEvent;
+  
+  // Initialize generator for signal processes. 
+  pythiaSignal.readString("HardQCD:all = on");    
+  pythiaSignal.readString("PhaseSpace:pTHatMin = 50.");
+  pythiaSignal.init( 2212, 2212, 2. * eBeam);
+
+  // Initialize generator for pileup (background) processes.
+  pythiaPileup.readString("Random:setSeed = on");    
+  pythiaPileup.readString("Random:seed = 10000002");     
+  pythiaPileup.readString("SoftQCD:all = on");    
+  pythiaPileup.init( 2212, 2212, 2. * eBeam);
+
+  // Initialize generators for beam A - gas (background) processes. 
+  pythiaBeamAGas.readString("Random:setSeed = on");    
+  pythiaBeamAGas.readString("Random:seed = 10000003");     
+  pythiaBeamAGas.readString("SoftQCD:all = on");    
+  pythiaBeamAGas.init( 2212, 2212, eBeam, 0.);
+
+  // Initialize generators for beam B - gas (background) processes. 
+  pythiaBeamBGas.readString("Random:setSeed = on");    
+  pythiaBeamBGas.readString("Random:seed = 10000004");     
+  pythiaBeamBGas.readString("SoftQCD:all = on");    
+  pythiaBeamBGas.init( 2212, 2212, 0., eBeam);
+
+  // Histograms: number of pileups, total charged multiplicity.
+  Hist nPileH("number of pileup events per signal event", 100, -0.5, 99.5);
+  Hist nAGH("number of beam A + gas events per signal event", 100, -0.5, 99.5);
+  Hist nBGH("number of beam B + gas events per signal event", 100, -0.5, 99.5);
+  Hist nChgH("number of charged multiplicity",100, -0.5, 1999.5);  
+  Hist sumPZH("total pZ of system",100, -100000., 100000.);  
+
+  // Loop over events. 
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+
+    // Generate a signal event. Copy this event into sumEvent. 
+    if (!pythiaSignal.next()) continue;
+    sumEvent = pythiaSignal.event;
+
+    // Select the number of pileup events to generate.
+    int nPileup = poisson(nPileupAvg, pythiaPileup.rndm); 
+    nPileH.fill( nPileup );
+
+    // Generate a number of pileup events. Add them to sumEvent.      
+    for (int iPileup = 0; iPileup < nPileup; ++iPileup) {
+      pythiaPileup.next();
+      sumEvent += pythiaPileup.event;
+    }
+
+    // Select the number of beam A + gas events to generate.
+    int nBeamAGas = poisson(nBeamAGasAvg, pythiaBeamAGas.rndm); 
+    nAGH.fill( nBeamAGas );
+
+    // Generate a number of beam A + gas events. Add them to sumEvent.      
+    for (int iAG = 0; iAG < nBeamAGas; ++iAG) {
+      pythiaBeamAGas.next();
+      sumEvent += pythiaBeamAGas.event;
+    }
+  
+    // Select the number of beam B + gas events to generate.
+    int nBeamBGas = poisson(nBeamBGasAvg, pythiaBeamBGas.rndm); 
+    nBGH.fill( nBeamBGas );
+
+    // Generate a number of beam B + gas events. Add them to sumEvent.      
+    for (int iBG = 0; iBG < nBeamBGas; ++iBG) {
+      pythiaBeamBGas.next();
+      sumEvent += pythiaBeamBGas.event;
+    }
+  
+    // List first few events.
+    if (iEvent < 1) {
+      pythiaSignal.info.list();
+      pythiaSignal.process.list();
+      sumEvent.list();
+    } 
+
+    // Find charged multiplicity.
+    int nChg = 0;
+    for (int i = 0; i < sumEvent.size(); ++i) 
+      if (sumEvent[i].isFinal() && sumEvent[i].isCharged()) ++nChg; 
+    nChgH.fill( nChg );
+
+    // Fill net pZ - nonvanishing owing to beam + gas.
+    sumPZH.fill( sumEvent[0].pz() ); 
+  // End of event loop 
+  }
+
+  // Statistics. Histograms.
+  pythiaSignal.statistics();
+  pythiaPileup.statistics();
+  pythiaBeamAGas.statistics();
+  pythiaBeamBGas.statistics();
+  cout << nPileH << nAGH << nBGH << nChgH << sumPZH;
+
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main20.cc b/PYTHIA8/pythia8145/examples/main20.cc
new file mode 100644 (file)
index 0000000..5b426ed
--- /dev/null
@@ -0,0 +1,64 @@
+// main20.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. It shows how PYTHIA 8 can write
+// a Les Houches Event File based on its process-level events.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+int main() {
+
+  // Generator. 
+  Pythia pythia;
+
+  // Process selection. Minimal masses for gamma*/Z and W+-.
+  pythia.readString("WeakDoubleBoson:all = on");    
+  pythia.readString("23:mMin = 50.");
+  pythia.readString("24:mMin = 50.");
+
+  // Switch off generation of steps subsequent to the process level one.
+  // (These will not be stored anyway, so only steal time.)
+  pythia.readString("PartonLevel:all = off");    
+
+  // Create an LHAup object that can access relevant information in pythia.
+  LHAupFromPYTHIA8 myLHA(&pythia.process, &pythia.info);
+
+  // Open a file on which LHEF events should be stored, and write header.
+  myLHA.openLHEF("weakbosons.lhe"); 
+
+  // Tevatron initialization. 
+  pythia.init( 2212, -2212, 1960.);
+
+  // Store initialization info in the LHAup object. 
+  myLHA.setInit();
+
+  // Write out this initialization info on the file.
+  myLHA.initLHEF();
+
+  // Loop over events.
+  for (int i = 0; i < 100; ++i) {
+
+    // Generate an event.
+    pythia.next();
+
+    // Store event info in the LHAup object. 
+    myLHA.setEvent();
+
+    // Write out this event info on the file. 
+    myLHA.eventLHEF();
+  }
+
+  // Statistics: full printout.
+  pythia.statistics();
+
+  // Update the cross section info based on Monte Carlo integration during run.
+  myLHA.updateSigma();
+
+  // Write endtag. Overwrite initialization info with new cross sections.
+  myLHA.closeLHEF(true);
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main21.cc b/PYTHIA8/pythia8145/examples/main21.cc
new file mode 100644 (file)
index 0000000..86e8f0d
--- /dev/null
@@ -0,0 +1,351 @@
+// main21.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how to feed in a single particle 
+// or a toy parton-level configurations.
+
+#include "Pythia.h"
+using namespace Pythia8; 
+
+//==========================================================================
+
+// Single-particle gun. The particle must be a colour singlet.
+// Input: flavour, energy, direction (theta, phi).
+// If theta < 0 then random choice over solid angle. 
+
+void fillParticle(int id, double ee, double thetaIn, double phiIn, 
+                 Event& event, ParticleData& pdt, Rndm& rndm) {
+
+  // Reset event record to allow for new event.
+  event.reset();
+
+  // Select particle mass; where relevant according to Breit-Wigner. 
+  double mm = pdt.mass(id);
+  double pp = sqrtpos(ee*ee - mm*mm);
+
+  // Angles as input or uniform in solid angle.
+  double cThe, sThe, phi;
+  if (thetaIn >= 0.) {
+    cThe = cos(thetaIn);
+    sThe = sin(thetaIn);
+    phi  = phiIn;
+  } else {
+    cThe = 2. * rndm.flat() - 1.;
+    sThe = sqrtpos(1. - cThe * cThe);
+    phi = 2. * M_PI * rndm.flat();
+  }
+
+  // Store the particle in the event record.
+  event.append( id, 1, 0, 0, pp * sThe * cos(phi), pp * sThe * sin(phi), 
+    pp * cThe, ee, mm); 
+}
+
+//==========================================================================
+
+// Simple method to do the filling of partons into the event record.
+
+void fillPartons(int type, double ee, Event& event, ParticleData& pdt, 
+  Rndm& rndm) {
+
+  // Reset event record to allow for new event.
+  event.reset();
+
+  // Information on a q qbar system, to be hadronized.
+  if (type == 1) {
+    int    id = 2;
+    double mm = pdt.m0(id);
+    double pp = sqrtpos(ee*ee - mm*mm);
+    event.append(  id, 23, 101,   0, 0., 0.,  pp, ee, mm); 
+    event.append( -id, 23,   0, 101, 0., 0., -pp, ee, mm);
+
+  // Information on a g g system, to be hadronized.
+  } else if (type == 2) {  
+    event.append( 21, 23, 101, 102, 0., 0.,  ee, ee); 
+    event.append( 21, 23, 102, 101, 0., 0., -ee, ee); 
+
+  // Information on a g g g system, to be hadronized.
+  } else if (type == 3) {  
+    event.append( 21, 23, 101, 102,        0., 0.,        ee, ee); 
+    event.append( 21, 23, 102, 103,  0.8 * ee, 0., -0.6 * ee, ee); 
+    event.append( 21, 23, 103, 101, -0.8 * ee, 0., -0.6 * ee, ee); 
+
+  // Information on a q q q junction system, to be hadronized.
+  } else if (type == 4 || type == 5) { 
+
+    // Need a colour singlet mother parton to define junction origin.
+    event.append( 1000022, -21, 0, 0, 2, 4, 0, 0, 
+                  0., 0., 1.01 * ee, 1.01 * ee); 
+
+    // The three endpoint q q q; the minimal system. 
+    double rt75 = sqrt(0.75);  
+    event.append( 2, 23, 1, 0, 0, 0, 101, 0,
+                          0., 0., 1.01 * ee, 1.01 * ee); 
+    event.append( 2, 23, 1, 0, 0, 0, 102, 0, 
+                   rt75 * ee, 0., -0.5 * ee,        ee ); 
+    event.append( 1, 23, 1, 0, 0, 0, 103, 0,
+                  -rt75 * ee, 0., -0.5 * ee,        ee );
+
+    // Define the qqq configuration as starting point for adding gluons.
+    if (type == 5) {
+      int colNow[4] = {0, 101, 102, 103}; 
+      Vec4 pQ[4];
+      pQ[1] = Vec4(0., 0., 1., 0.);
+      pQ[2] = Vec4( rt75, 0., -0.5, 0.);
+      pQ[3] = Vec4(-rt75, 0., -0.5, 0.);
+
+      // Minimal cos(q-g opening angle), allows more or less nasty events.
+      double cosThetaMin =0.;
+      
+      // Add a few gluons (almost) at random. 
+      for (int nglu = 0; nglu < 5; ++nglu) { 
+        int iq = 1 + int( 2.99999 * rndm.flat() );
+        double px, py, pz, e, prod; 
+        do {
+          e =  ee * rndm.flat();
+          double cThe = 2. * rndm.flat() - 1.;
+          double phi = 2. * M_PI * rndm.flat(); 
+          px = e * sqrt(1. - cThe*cThe) * cos(phi);
+          py = e * sqrt(1. - cThe*cThe) * sin(phi);
+          pz = e * cThe;
+          prod = ( px * pQ[iq].px() + py * pQ[iq].py() + pz * pQ[iq].pz() ) 
+            / e;
+        } while (prod < cosThetaMin); 
+        int colNew = 104 + nglu;
+        event.append( 21, 23, 1, 0, 0, 0, colNew, colNow[iq], 
+          px, py, pz, e, 0.);
+        colNow[iq] = colNew;   
+      }
+      // Update daughter range of mother.
+      event[1].daughters(1, event.size() - 1);  
+    }
+
+  // Information on a q q qbar qbar dijunction system, to be hadronized.
+  } else if (type >= 6) {
+
+    // The two fictitious beam remnant particles; needed for junctions.
+    event.append( 2212, -12, 0, 0, 3, 5, 0, 0, 0., 0., ee, ee, 0.);
+    event.append(-2212, -12, 0, 0, 6, 8, 0, 0, 0., 0., ee, ee, 0.);
+
+    // Opening angle between "diquark" legs.
+    double theta = 0.2;
+    double cThe = cos(theta);
+    double sThe = sin(theta);  
+
+    // Set one colour depending on whether more gluons or not.
+    int acol = (type == 6) ? 103 : 106;
+
+    // The four endpoint q q qbar qbar; the minimal system. 
+    // Two additional fictitious partons to make up original beams.
+    event.append(  2,   23, 1, 0, 0, 0, 101, 0,
+                  ee * sThe, 0.,  ee * cThe, ee, 0.); 
+    event.append(  1,   23, 1, 0, 0, 0, 102, 0, 
+                 -ee * sThe, 0.,  ee * cThe, ee, 0.); 
+    event.append(  2, -21, 1, 0, 0, 0, 103, 0,     
+                         0., 0.,  ee       , ee, 0.); 
+    event.append( -2,   23, 2, 0, 0, 0, 0, 104, 
+                  ee * sThe, 0., -ee * cThe, ee, 0.); 
+    event.append( -1,   23, 2, 0, 0, 0, 0, 105, 
+                 -ee * sThe, 0., -ee * cThe, ee, 0.); 
+    event.append( -2, -21, 2, 0, 0, 0, 0, acol,    
+                         0., 0., -ee       , ee, 0.); 
+
+    // Add extra gluons on string between junctions.
+    if (type == 7) {
+      event.append( 21, 23, 5, 8, 0, 0, 103, 106, 0., ee, 0., ee, 0.); 
+    } else if (type == 8) {
+      event.append( 21, 23, 5, 8, 0, 0, 103, 108, 0., ee, 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 108, 106, 0.,-ee, 0., ee, 0.); 
+    } else if (type == 9) {
+      event.append( 21, 23, 5, 8, 0, 0, 103, 107, 0., ee, 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 107, 108, ee, 0., 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 108, 106, 0.,-ee, 0., ee, 0.); 
+    } else if (type == 10) {
+      event.append( 21, 23, 5, 8, 0, 0, 103, 107, 0., ee, 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 107, 108, ee, 0., 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 108, 109, 0.,-ee, 0., ee, 0.); 
+      event.append( 21, 23, 5, 8, 0, 0, 109, 106,-ee, 0., 0., ee, 0.); 
+    }
+
+  // No more cases: done.
+  } 
+}
+
+//==========================================================================
+
+int main() {
+
+  // Pick kind of events to generate:
+  // 0 = single-particle gun.
+  // 1 = q qbar.
+  // 2 = g g. 
+  // 3 = g g g.
+  // 4 = minimal q q q junction topology.
+  // 5 = q q q junction topology with gluons on the strings.
+  // 6 = q q qbar qbar dijunction topology, no gluons.
+  // 7 - 10 : ditto, but with 1 - 4 gluons on string between junctions.
+  int type = 0;
+
+  // Set particle species and energy for single-particle gun.
+  int    idGun = 15;
+  double eeGun = 20.; 
+
+  // Set typical energy per parton.
+  double ee = 20.0;
+
+  // Set number of events to generate and to list.
+  int nEvent = 10000;
+  int nList = 3;
+
+  // Generator; shorthand for event and particleData.                           
+  Pythia pythia;  
+  Event& event      = pythia.event;
+  ParticleData& pdt = pythia.particleData;
+
+  // Key requirement: switch off ProcessLevel, and thereby also PartonLevel.
+  pythia.readString("ProcessLevel:all = off");
+
+  // Optionally switch off decays.
+  //pythia.readString("HadronLevel:Decay = off");
+
+  // Provide printout of initial information.        
+  pythia.settings.listChanged();
+  // Initialize.
+  pythia.init();
+
+  // Book histograms.                          
+  Hist epCons("deviation from energy-momentum conservation",100,0.,1e-4);
+  Hist chgCons("deviation from charge conservation",57,-9.5,9.5);
+  Hist nFinal("final particle multiplicity",100,-0.5,99.5);   
+  Hist dnparticledp("dn/dp for particles",100,0.,ee);
+  Hist status85("multiplicity status code 85",50,-0.5,49.5);
+  Hist status86("multiplicity status code 86",50,-0.5,49.5);
+  Hist status83("multiplicity status code 83",50,-0.5,49.5);
+  Hist status84("multiplicity status code 84",50,-0.5,49.5);
+  Hist dndtheta("particle flow in event plane",100,-M_PI,M_PI);
+  Hist dedtheta("energy flow in event plane",100,-M_PI,M_PI);
+  Hist dpartondtheta("parton flow in event plane",100,-M_PI,M_PI);
+  Hist dndyAnti("dn/dy primaries antijunction",100, -10., 10.);
+  Hist dndyJun("dn/dy primaries junction",100, -10., 10.);
+  Hist dndySum("dn/dy all primaries",100, -10., 10.);
+  
+  // Begin of event loop.
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) cout << " Now begin event " 
+      << iEvent << endl;
+
+    // Set up single particle, with random direction in solid angle.
+    if (type == 0) fillParticle( idGun, eeGun, -1., 0., event, pdt, pythia.rndm);
+
+    // Set up parton-level configuration.
+    else fillPartons( type, ee, event, pdt, pythia.rndm); 
+
+    // Generate events. Quit if failure.
+    if (!pythia.next()) {
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events.
+    if (iEvent < nList) { 
+      event.list();
+      // Also list junctions.
+      event.listJunctions();
+    }
+
+    // Initialize statistics. 
+    Vec4 pSum = - event[0].p();
+    double chargeSum = 0.;
+    if (type == 0) chargeSum = -event[1].charge();
+    if (type == 4 || type == 5) chargeSum = -1;
+    int nFin = 0;  
+    int n85 = 0;
+    int n86 = 0;
+    int n83 = 0;
+    int n84 = 0;
+                          
+    // Loop over all particles.
+    for (int i = 0; i < event.size(); ++i) {
+      int status = event[i].statusAbs();
+
+      // Find any unrecognized particle codes.
+      int id = event[i].id();
+      if (id == 0 || !pdt.isParticle(id))
+        cout << " Error! Unknown code id = " << id << "\n"; 
+
+      // Find particles with E-p mismatch.
+      double eCalc = event[i].eCalc();
+      if (abs(eCalc/event[i].e() - 1.) > 1e-6) cout << " e mismatch, i = "
+        << i << " e_nominal = " << event[i].e() << " e-from-p = " 
+        << eCalc << " m-from-e " << event[i].mCalc() << "\n";
+
+      // Parton flow in event plane.
+      if (status == 71 || status == 72) { 
+        double thetaXZ = event[i].thetaXZ();
+        dpartondtheta.fill(thetaXZ);
+      }
+
+      // Origin of primary hadrons.
+      if (status == 85) ++n85;
+      if (status == 86) ++n86;
+      if (status == 83) ++n83;
+      if (status == 84) ++n84;
+
+      // Flow of primary hadrons in the event plane.
+      if (status > 80 && status < 90) {
+        double eAbs = event[i].e();
+        if (eAbs < 0.) {cout << " e < 0 line " << i; event.list();}
+        double thetaXZ = event[i].thetaXZ();
+        dndtheta.fill(thetaXZ);
+        dedtheta.fill(thetaXZ, eAbs);
+        // Rapidity distribution of primary hadrons.
+        double y = event[i].y();
+        dndySum.fill(y);
+        if (type >= 6) {
+          int motherId = event[event[i].mother1()].id();
+          if (motherId > 0 ) dndyJun.fill(event[i].y()); 
+          else dndyAnti.fill(event[i].y());
+       }
+      }
+
+      // Study final-state particles.
+      if (event[i].isFinal()) {
+        pSum += event[i].p();
+        chargeSum += event[i].charge();
+        nFin++;
+        double pAbs = event[i].pAbs();
+        dnparticledp.fill(pAbs);
+      }
+    }
+    // Fill histograms once for each event.
+    double epDev = abs(pSum.e()) + abs(pSum.px()) + abs(pSum.py())
+      + abs(pSum.pz());
+    epCons.fill(epDev);
+    chgCons.fill(chargeSum);
+    nFinal.fill(nFin); 
+    status85.fill(n85);
+    status86.fill(n86);
+    status83.fill(n83);
+    status84.fill(n84);
+    if (epDev > 1e-3  || abs(chargeSum) > 0.1) event.list(); 
+                       
+  // End of event loop.
+  }                                           
+
+  // Print statistics, histograms and done.
+  pythia.statistics();
+  cout << epCons << chgCons << nFinal << dnparticledp
+       << dndtheta << dedtheta << dpartondtheta << dndySum;
+  if (type >= 4) cout << status85 << status86 << status83 
+       << status84; 
+  if (type >= 6) cout << dndyJun << dndyAnti;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main22.cc b/PYTHIA8/pythia8145/examples/main22.cc
new file mode 100644 (file)
index 0000000..279d7af
--- /dev/null
@@ -0,0 +1,100 @@
+// main22.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Peter Skands, 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 run SUSY processes in Pythia8.
+// All input is specified in the main22.cmnd file.
+
+#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("main22.cmnd");    
+
+  // Extract settings to be used in the main program.
+  int nEvent   = pythia.mode("Main:numberOfEvents");
+  int nList    = pythia.mode("Main:numberToList");
+  int nShow    = pythia.mode("Main:timesToShow");
+  int nAbort   = pythia.mode("Main:timesAllowErrors"); 
+  bool showCS  = pythia.flag("Main:showChangedSettings");
+  bool showAS  = pythia.flag("Main:showAllSettings");
+  bool showCPD = pythia.flag("Main:showChangedParticleData");
+  bool showAPD = pythia.flag("Main:showAllParticleData");
+  double eCM   = pythia.parm("Beams:eCM");
+
+  // Initialize. Beam parameters set in .cmnd file.
+  pythia.init();
+
+  // List changed data.
+  if (showCS) pythia.settings.listChanged();
+  if (showAS) pythia.settings.listAll();
+
+  // List particle data.  
+  if (showCPD) pythia.particleData.listChanged();
+  if (showAPD) pythia.particleData.listAll();
+
+  // Histograms.
+  double epTol = 1e-6 * eCM;
+  Hist epCons("deviation from energy-momentum conservation",100,0.,epTol);
+  Hist nFinal("final particle multiplicity",100,-0.5,799.5);
+  Hist dnparticledy("dn/dy for particles",100,-10.,10.);
+
+  // Begin event loop.
+  int nPace = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if failure.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events, both hard process and complete events.
+    if (iEvent < nList) { 
+      pythia.process.list();
+      event.list();
+    }
+
+    // Loop over final particles in the event. 
+    int nFin = 0;
+    Vec4 pSum;
+    for (int i = 0; i < event.size(); ++i) if (event[i].isFinal()) {
+      nFin++;
+      pSum += event[i].p();
+      dnparticledy.fill(event[i].y());
+    }
+
+    // Check and print event with too big energy-momentum deviation.
+    nFinal.fill(nFin);
+    double epDev = abs(pSum.e() - eCM) + abs(pSum.px()) + abs(pSum.py())
+      + abs(pSum.pz());
+    epCons.fill(epDev);
+    if (epDev > epTol) {
+      cout << " Warning! Event with epDev = " << scientific 
+           << setprecision(4) << epDev << " now listed:";
+      event.list();
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics and histogram output.
+  pythia.statistics();
+  cout << epCons << nFinal << dnparticledy; 
+
+  return 0;
+}
+
diff --git a/PYTHIA8/pythia8145/examples/main22.cmnd b/PYTHIA8/pythia8145/examples/main22.cmnd
new file mode 100644 (file)
index 0000000..8bceeae
--- /dev/null
@@ -0,0 +1,44 @@
+! main22.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 that could be used in a main program, if desired.
+Main:numberOfEvents = 10000        ! number of events to generate
+Main:numberToList = 2              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+Main:showAllSettings = off         ! print all flags/modes/parameters
+Main:showChangedParticleData = off  ! print changed particle and decay data
+#Main:showAllParticleData = off      ! print all particle and decay data
+
+! 2) 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
+
+! 3) Read SLHA spectrum, with or without DECAY tables
+SLHA:file = sps1a.spc       
+#SLHA:file = sps1aWithDecays.spc      
+
+! 4) Process selection 
+SUSY:all = on                      ! Switches on ALL (~400) SUSY processes
+#SUSY:gg2gluinogluino  = on      
+#SUSY:qqbar2gluinogluino  = on
+#SUSY:qg2squarkgluino = on
+#SUSY:gg2squarkantisquark = on
+#SUSY:qqbar2squarkantisquark = on
+#SUSY:qq2squarksquark = on
+#SUSY:qqbar2chi0chi0  = on
+#SUSY:qqbar2chi+-chi0 = on
+#SUSY:qqbar2chi+chi-  = on
+#SUSY:qg2chi0squark = on
+#SUSY:qg2chi+-squark  = on
+! Optionally select only specific sparticle codes in the final state
+#SUSY:idA        = 2000001           ! 0: all
+#SUSY:idB        = 2000001           ! 0: all
+
+! 5) Settings for the event generation process in the Pythia8 library.
+PartonLevel:MI = off               ! no multiple interactions
+PartonLevel:ISR = off              ! no initial-state radiation 
+PartonLevel:FSR = off              ! no final-state radiation
+HadronLevel:Hadronize = off        ! no hadronization
diff --git a/PYTHIA8/pythia8145/examples/main23.cc b/PYTHIA8/pythia8145/examples/main23.cc
new file mode 100644 (file)
index 0000000..1bfd841
--- /dev/null
@@ -0,0 +1,157 @@
+// main23.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrates how decays could be handled externally.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+// A derived class to do J/psi decays.
+
+class JpsiDecay : public DecayHandler {
+
+public:
+
+  // Constructor.
+  JpsiDecay(ParticleData* pdtPtrIn, Rndm* rndmPtrIn) {times = 0; 
+    pdtPtr = pdtPtrIn; rndmPtr = rndmPtrIn;}
+
+  // Routine for doing the decay.
+  bool decay(vector<int>& idProd, vector<double>& mProd, 
+    vector<Vec4>& pProd, int iDec, const Event& event);
+
+private:
+
+  // Count number of times JpsiDecay is called.
+  int times;
+
+  // Pointer to the particle data table.
+  ParticleData* pdtPtr;
+
+  // Pointer to the random number generator.
+  Rndm* rndmPtr;
+
+};
+
+//--------------------------------------------------------------------------
+
+// The actual J/psi decay routine.
+// Not intended for realism, just to illustrate the principles.
+
+bool JpsiDecay::decay(vector<int>& idProd, vector<double>& mProd, 
+  vector<Vec4>& pProd, int iDec, const Event& event) {
+
+  // Always do decay J/psi -> mu+ mu-; store the muons.
+  idProd.push_back(-13);
+  idProd.push_back(13);
+  
+  // Muon mass(es), here from Pythia tables, also stored.
+  double mMuon = pdtPtr->m0(13); 
+  mProd.push_back(mMuon);
+  mProd.push_back(mMuon);
+
+  // Calculate muon energy and momentum in J/psi rest frame.
+  double eMuon = 0.5 * mProd[0];
+  double pAbsMuon = sqrt(eMuon * eMuon - mMuon * mMuon);
+
+  // Assume decay angles isotropic in rest frame.
+  double cosTheta = 2. * rndmPtr->flat() - 1.;
+  double sinTheta = sqrt(max(0., 1. - cosTheta * cosTheta));
+  double phi = 2. * M_PI * rndmPtr->flat();
+  double pxMuon = pAbsMuon * sinTheta * cos(phi); 
+  double pyMuon = pAbsMuon * sinTheta * sin(phi); 
+  double pzMuon = pAbsMuon * cosTheta; 
+
+  // Define mu+ and mu- four-vectors in the J/psi rest frame.
+  Vec4 pMuPlus(   pxMuon,  pyMuon,  pzMuon, eMuon);  
+  Vec4 pMuMinus( -pxMuon, -pyMuon, -pzMuon, eMuon);  
+
+  // Boost them by velocity vector of the J/psi mother and store.
+  pMuPlus.bst(pProd[0]);
+  pMuMinus.bst(pProd[0]);
+  pProd.push_back(pMuPlus);
+  pProd.push_back(pMuMinus);
+
+  // Print message the first few times, to show that it works.
+  if (times++ < 10) {
+    int iMother = event[iDec].mother1();
+    int idMother = event[iMother].id();
+    cout << " J/psi decay performed, J/psi in line " << iDec 
+         << ", mother id = " << idMother << "\n";
+  }
+
+  // Done
+  return true;
+
+}
+
+//==========================================================================
+
+int main() {
+
+  // Number of events to generate and to list. Max number of errors.
+  int nEvent = 100;
+  int nList = 2;
+  int nAbort = 5;
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // A class to do J/psi decays externally. 
+  DecayHandler* handleDecays = new JpsiDecay(&pythia.particleData, 
+    &pythia.rndm);
+
+  // The list of particles the class can handle.
+  vector<int> handledParticles;
+  handledParticles.push_back(443);
+
+  // Hand pointer and list to Pythia.
+  pythia.setDecayPtr( handleDecays, handledParticles);
+
+  // Initialization for charmonium (singlet+octet) production at the LHC.
+  pythia.readString("Charmonium:all = on");
+  pythia.readString("PhaseSpace:pTHatMin = 20.");
+  pythia.init( 2212, 2212, 14000.);
+
+  // Begin event loop.
+  int iList = 0;
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) cout << " Now begin event " 
+      << iEvent << "\n";
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+
+    // Look for event with externally handled decays.
+    bool externalDecay = false;
+    for (int i = 0; i < pythia.event.size(); ++i) {
+      int status = pythia.event[i].statusAbs();
+      if (status == 93 || status == 94) {externalDecay = true; break;}
+    }  
+    // List first few events with external decay.
+    if (externalDecay && ++iList <= nList) { 
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics.
+  pythia.statistics();
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main24.cc b/PYTHIA8/pythia8145/examples/main24.cc
new file mode 100644 (file)
index 0000000..1f241b8
--- /dev/null
@@ -0,0 +1,160 @@
+// main24.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a simple test program. 
+// It illustrated how random numbers could be generated externally.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//==========================================================================
+
+// A derived class to generate random numbers.
+// A guranteed VERY STUPID generator, just to show principles.
+
+class stupidRndm : public RndmEngine {
+
+public:
+
+  // Constructor.
+  stupidRndm() { init();}
+
+  // Routine for generating a random number.
+  double flat();
+
+private:
+
+  // Initialization.
+  void init();
+
+  // State of the generator.
+  int number;
+  double sqrt2, sqrt3, sqrt5, sqrt7, sqrt11, value;   
+
+};
+
+//--------------------------------------------------------------------------
+
+// Initialization method for the random numbers.
+
+void stupidRndm::init() {
+
+  // Calculater some irrantional numbers, truncated to below 1.
+  sqrt2 = sqrt(2.) - 1.;
+  sqrt3 = sqrt(2.) - 1.;
+  sqrt5 = sqrt(2.) - 2.;
+  sqrt7 = sqrt(2.) - 2.;
+  sqrt11 = sqrt(11.) - 3.;
+    
+  // Initial values.
+  number = 0;
+  value = 0.; 
+
+} 
+
+//--------------------------------------------------------------------------
+
+// Initialization method for the random numbers.
+
+double stupidRndm::flat() {
+
+  // Update counter. Add to current value.
+  do {
+    number = (++number)%210;
+    value += number%2 * sqrt2 + number%3 * sqrt3 + number%5 * sqrt5
+           + number%7 * sqrt7 + sqrt11;
+    value -= double(int(value));
+    if (value < 0.) value += 1.; 
+  } while (value <= 0. || value >= 1.);  
+
+  // Return new value.
+  return value;
+
+}
+
+//==========================================================================
+
+int main() {
+
+  // Number of events to generate and to list. Max number of errors.
+  int nEvent = 100;
+  int nList = 1;
+  int nAbort = 5;
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // Study standard Pythia random number generator.
+  Hist rndmDist("standard random number distribution", 100, 0., 1.);
+  Hist rndmCorr("standard random number correlation", 100, 0., 1.);
+  double rndmNow;
+  double rndmOld = pythia.rndm.flat();
+  for (int i = 0; i < 1000000; ++i) {
+    rndmNow = pythia.rndm.flat();
+    rndmDist.fill(rndmNow);
+    rndmCorr.fill( abs(rndmNow - rndmOld) );
+    rndmOld = rndmNow;
+  }    
+  cout << rndmDist << rndmCorr;
+
+  // A class to do random numbers externally. Hand pointer to Pythia.
+  RndmEngine* badRndm = new stupidRndm();
+  pythia.setRndmEnginePtr( badRndm);
+
+  // Generate and show some "random" numbers.
+  /*
+  cout << fixed << setprecision(8); 
+  for (int i = 0; i < 500; ++i) {
+    cout << setw(12) << pythia.rndm.flat();
+    if(i%10 == 9) cout << "\n";
+  } 
+  */
+
+  // Study bad "new" random number generator.
+  Hist rndmDist2("stupid random number distribution", 100, 0., 1.);
+  Hist rndmCorr2("stupid random number correlation", 100, 0., 1.);
+  rndmOld = pythia.rndm.flat();
+  for (int i = 0; i < 100000; ++i) {
+    rndmNow = pythia.rndm.flat();
+    rndmDist2.fill(rndmNow);
+    rndmCorr2.fill( abs(rndmNow - rndmOld) );
+    rndmOld = rndmNow;
+  }    
+  cout << rndmDist2 << rndmCorr2;
+
+  // Initialization for ttbar production at the LHC.
+  pythia.readString("Top:gg2ttbar = on");
+  pythia.readString("Top:qqbar2ttbar = on");
+  pythia.init( 2212, 2212, 14000.);
+
+  // Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) cout << " Now begin event " 
+      << iEvent << "\n";
+
+    // Generate events. Quit if failure.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events.
+    if (++iEvent <= nList) { 
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics.
+  pythia.statistics();
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main25.cc b/PYTHIA8/pythia8145/examples/main25.cc
new file mode 100644 (file)
index 0000000..df5839c
--- /dev/null
@@ -0,0 +1,206 @@
+// main25.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Simple illustration how to provide your own cross-section class,
+// with an instance handed in to Pythia for internal generation.
+// The class is a lighly modified copy of an existing Pythia class,
+// and cross sections are compared with the internal implementation. 
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+//==========================================================================
+
+// A derived class for b g -> H0 b (Standard Model Higgs).
+
+class Sigma2bg2Hb : public Sigma2Process {
+
+public:
+
+  // Constructor.
+  Sigma2bg2Hb() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). 
+  virtual double sigmaHat();
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()    const {return "b g -> H b";}
+  virtual int    code()    const {return 10001;}
+  virtual string inFlux()  const {return "qg";}
+  virtual int    id3Mass() const {return 25;}
+  virtual int    id4Mass() const {return 5;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  double m2b, m2W, thetaWRat, openFrac, sigma;
+
+};
+
+//--------------------------------------------------------------------------
+
+// Initialize process. 
+  
+void Sigma2bg2Hb::initProc() {
+
+  // Masses and couplings.
+  m2b       = pow2( particleDataPtr->m0(5) );
+  m2W       = pow2( particleDataPtr->m0(24) );
+  thetaWRat = 1. / (24. * couplingsPtr->sin2thetaW()); 
+
+  // Suppression from secondary widths.
+  openFrac = particleDataPtr->resOpenFrac(25);
+  
+} 
+
+//--------------------------------------------------------------------------
+
+// Evaluate sigmaHat(sHat); first step when inflavours unknown. 
+
+void Sigma2bg2Hb::sigmaKin() { 
+
+  // Initial values. Running mass provides coupling.
+  double mHat   = sqrt(sH);
+  double m2bRun = pow2( particleDataPtr->mRun(5, mHat) );
+
+  // Cross section.
+  sigma = (M_PI / sH2) * alpS * alpEM * thetaWRat * (m2bRun/m2W) 
+    * ( sH / (m2b - uH) + 2. * m2b * (s3 - uH) / pow2(m2b - uH) 
+    + (m2b - uH) / sH - 2. * m2b / (m2b - uH) 
+    + 2. * (s3 - uH)  * (s3 - m2b - sH) / ((m2b - uH) * sH) );
+  sigma *= openFrac;
+
+}
+
+//--------------------------------------------------------------------------
+
+// Evaluate sigmaHat(sHat); second step for given inflavours.
+
+double Sigma2bg2Hb::sigmaHat() { 
+
+  // Cross section vanishing except for incoming b(bar) quark.
+  if (abs(id1) != 5 && abs(id2) != 5) return 0.;
+  // Cross section as already calculated.
+  return sigma;  
+
+}
+
+//--------------------------------------------------------------------------
+
+// Select identity, colour and anticolour.
+
+void Sigma2bg2Hb::setIdColAcol() {
+
+  // Flavour set up for b g -> H0 q.
+  int idq = (id2 == 21) ? id1 : id2;
+  setId( id1, id2, 25, idq);
+
+  // tH defined between b_in and b_out: must swap tHat <-> uHat if b g in.
+  swapTU = (id2 == 21); 
+
+  // Colour flow topologies. Swap when antiquarks.
+  if (id2 == 21) setColAcol( 1, 0, 2, 1, 0, 0, 2, 0);
+  else           setColAcol( 2, 1, 1, 0, 0, 0, 2, 0);
+  if (idq < 0) swapColAcol();
+
+}
+
+//--------------------------------------------------------------------------
+
+// Evaluate weight for Z0 Z0 or W+W- decay angles in Higgs decay.
+
+double Sigma2bg2Hb::weightDecay( Event& process, int iResBeg,
+  int iResEnd) {
+
+  // For Higgs decay hand over to standard routine, else done.
+  if (process[process[iResBeg].mother1()].idAbs() == 25) 
+       return weightHiggsDecay( process, iResBeg, iResEnd);
+  else return 1.; 
+
+}
+
+//==========================================================================
+
+int main() {
+
+  // Number of events to generate and to list. Max number of errors.
+  // Warning: generation of complete events is much slower than if you use
+  // PartonLevel:all = off to only get cross sections, so adjust nEvent.
+  int nEvent = 1000;
+  int nList  = 1;
+  int nAbort = 5;
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // A class to generate the b g -> H b process from external matrix element. 
+  SigmaProcess* sigma2bg2Hb = new Sigma2bg2Hb();
+
+  // Hand pointer to Pythia.
+  pythia.setSigmaPtr( sigma2bg2Hb);
+
+  // Optionally compare with (almost) same process implemented internally.
+  pythia.readString("HiggsSM:qg2Hq = on");
+
+  // Phase space cut on pThat.
+  pythia.readString("PhaseSpace:pTHatMin = 20.");
+
+  // Optionally only want to study H0 -> gamma gamma channel.
+  pythia.readString("25:onMode = off");
+  pythia.readString("25:onIfMatch = 22 22");
+
+  // Optionally only compare cross sections.
+  //pythia.readString("PartonLevel:all = off");
+
+  // Initialization for LHC.
+  pythia.init( 2212, 2212, 14000.);
+
+  // List changes.
+  pythia.settings.listChanged();
+  pythia.particleData.listChanged();
+
+  // Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) cout << " Now begin event " 
+      << iEvent << "\n";
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+  // End of event loop.
+  }
+
+  // Final statistics.
+  pythia.statistics();
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main26.cc b/PYTHIA8/pythia8145/examples/main26.cc
new file mode 100644 (file)
index 0000000..786bdb4
--- /dev/null
@@ -0,0 +1,294 @@
+// main26.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Simple illustration how to provide your own resonance-width class and
+// your own cross-section class, with instances handed in to Pythia.
+// The hypothetical scenario is that top would have been so long-lived
+// that a toponium resonance Theta could form. Then production could
+// proceed via q qbar -> gamma*/Z* -> Theta, with decay either to 
+// a fermion pair or (dominantly) to three gluons.
+// The implementation is not physically correct in any number of ways,
+// but should exemplify the strategy needed for realistic cases.
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+  
+//==========================================================================
+
+// The ResonanceTheta class handles a toponium resonance.
+
+class ResonanceTheta : public ResonanceWidths {
+
+public:
+
+  // Constructor. 
+  ResonanceTheta(int idResIn) {initBasic(idResIn);} 
+
+private: 
+
+  // Locally stored properties and couplings.
+  double normTheta2qqbar, normTheta2llbar, normTheta2ggg;
+  // Initialize constants.
+  virtual void initConstants(); 
+  // Calculate various common prefactors for the current mass.
+  // Superfluous here, so skipped.
+  //virtual void calcPreFac(bool = false);
+
+  // Calculate width for currently considered channel.
+  virtual void calcWidth(bool = false);
+
+};
+
+//--------------------------------------------------------------------------
+
+// Initialize constants.
+
+void ResonanceTheta::initConstants() {
+
+  // Dummy normalization of couplings to the allowed decay channels.
+  normTheta2qqbar = 0.0001;
+  normTheta2llbar = 0.0001;
+  normTheta2ggg   = 0.001; 
+}
+
+//--------------------------------------------------------------------------
+
+// Calculate width for currently considered channel.
+
+void ResonanceTheta::calcWidth(bool) {
+
+  // Expression for Theta -> q qbar (q up to b). Colour factor.
+  if (id1Abs < 6) widNow = 3. * normTheta2qqbar * mHat; 
+
+  // Expression for Theta -> l lbar (l = e, mu, tau).
+  else if (id1Abs == 11  || id1Abs == 13 || id1Abs == 15) 
+    widNow = normTheta2llbar * mHat; 
+
+  // Expression for Theta -> g g g. Colour factor.
+  else if (id1Abs == 21) widNow = 8. * normTheta2ggg * mHat; 
+
+}
+//==========================================================================
+
+// A derived class for q qbar -> Theta (toponium bound state).
+
+class Sigma1qqbar2Theta : public Sigma1Process {
+
+public:
+
+  // Constructor.
+  Sigma1qqbar2Theta() {}
+
+  // Initialize process. 
+  virtual void initProc(); 
+
+  // Calculate flavour-independent parts of cross section.
+  virtual void sigmaKin();
+
+  // Evaluate sigmaHat(sHat). Assumed flavour-independent so simple. 
+  virtual double sigmaHat() {return sigma;}
+
+  // Select flavour, colour and anticolour.
+  virtual void setIdColAcol();
+
+  // Evaluate weight for decay angles.
+  virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
+
+  // Info on the subprocess.
+  virtual string name()       const {return "q qbar -> Theta";}
+  virtual int    code()       const {return 621;}
+  virtual string inFlux()     const {return "qqbarSame";}
+  virtual int    resonanceA() const {return 663;}
+
+private:
+
+  // Store flavour-specific process information and standard prefactor.
+  int    idTheta;
+  double mRes, GammaRes, m2Res, GamMRat, normTheta2qqbar, sigma;
+
+  // Pointer to properties of Theta, to access decay width.
+  ParticleDataEntry* particlePtr;
+
+};
+
+//--------------------------------------------------------------------------
+
+// Initialize process. 
+  
+void Sigma1qqbar2Theta::initProc() {
+
+  // Store Theta mass and width for propagator. 
+  idTheta  = 663;
+  mRes     = particleDataPtr->m0(idTheta);
+  GammaRes = particleDataPtr->mWidth(idTheta);
+  m2Res    = mRes*mRes;
+  GamMRat  = GammaRes / mRes;
+
+  // Same normlization as in ResonanceTheta for coupling strength.
+  normTheta2qqbar = 0.0001;
+
+  // Set pointer to particle properties and decay table.
+  particlePtr = particleDataPtr->particleDataEntryPtr(idTheta);
+  
+} 
+
+//--------------------------------------------------------------------------
+
+// Evaluate sigmaHat(sHat); first step when inflavours unknown. 
+
+void Sigma1qqbar2Theta::sigmaKin() { 
+
+  // Incoming width with colour factor.
+  double widthIn  = normTheta2qqbar * mH / 3.; 
+
+  // Breit-Wigner, including some (guessed) spin factors.
+  double sigBW    = 12. * M_PI / ( pow2(sH - m2Res) + pow2(sH * GamMRat) ); 
+
+  // Outgoing width: only includes channels left open.
+  double widthOut = particlePtr->resWidthOpen(663, mH);    
+
+  // Total answer.
+  sigma = widthIn * sigBW * widthOut;
+
+}
+
+//--------------------------------------------------------------------------
+
+// Select identity, colour and anticolour.
+
+void Sigma1qqbar2Theta::setIdColAcol() {
+
+  // Flavours trivial.
+  setId( id1, id2, idTheta);
+
+  // Colour flow topologies. Swap when antiquarks.
+  setColAcol( 1, 0, 0, 1, 0, 0);
+  if (id1 < 0) swapColAcol();
+
+}
+
+//--------------------------------------------------------------------------
+
+// Evaluate weight for Theta -> g g g.
+
+double Sigma1qqbar2Theta::weightDecay( Event& process, int iResBeg,
+  int iResEnd) {
+
+  // Should be Theta decay. (This is only option here, so overkill.)
+  if (iResEnd != iResBeg || process[iResBeg].idAbs() != idTheta) 
+    return 1.;
+
+  // Should be decay to three gluons.
+  int i1 = process[iResBeg].daughter1();
+  int i2 = i1 + 1;
+  int i3 = i2 + 1;
+  if (i3 != process[iResBeg].daughter2() || process[i1].id() != 21)
+    return 1.;
+
+  // Energy fractions x_i = 2 E_i/m_Theta of gluons in Theta rest frame.
+  double x1 = 2. * process[i1].p() * process[iResBeg].p()
+            / process[iResBeg].m2();
+  double x2 = 2. * process[i2].p() * process[iResBeg].p()
+            / process[iResBeg].m2();
+  double x3 = 2. * process[i3].p() * process[iResBeg].p()
+            / process[iResBeg].m2();
+
+  // Matrix-element expression for Theta -> g g g.
+  double wtME = pow2( (1. - x1) / (x2 * x3) ) 
+    + pow2( (1. - x2) / (x1 * x3) ) + pow2( (1. - x3) / (x1 * x2) );
+  double wtMEmax = 2.;
+  return wtME / wtMEmax;
+}
+
+//==========================================================================
+
+int main() {
+
+  // Number of events to generate and to list. Max number of errors.
+  // Warning: generation of complete events is much slower than if you use
+  // PartonLevel:all = off to only get cross sections, so adjust nEvent.
+  int nEvent = 1000;
+  int nList = 1;
+  int nAbort = 5;
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // Create the toponium resonance and a few production/decay channels.
+  // Warning: many more exist, e.g. weak ones of one top quark.
+  // Note: to obtain the correct width for the Breit-Wigner you must
+  // include all channels, but you only need leave those on that you
+  // want to study.
+  pythia.readString("663:new = Theta void 3 0 0 342.0 0.2 300. 400. 0.");
+  pythia.readString("663:addChannel = 1 0. 0 1 -1");
+  pythia.readString("663:addChannel = 1 0. 0 2 -2");
+  pythia.readString("663:addChannel = 1 0. 0 3 -3");
+  pythia.readString("663:addChannel = 1 0. 0 4 -4");
+  pythia.readString("663:addChannel = 1 0. 0 5 -5");
+  pythia.readString("663:addChannel = 1 0. 0 11 -11");
+  pythia.readString("663:addChannel = 1 0. 0 13 -13");
+  pythia.readString("663:addChannel = 1 0. 0 15 -15");
+  pythia.readString("663:addChannel = 1 0. 0 21 21 21");  
+
+  // Create instance of a class to calculate the width of Theta to the 
+  // above channels. Hand in pointer to Pythia. 
+  ResonanceWidths* resonanceTheta = new ResonanceTheta(663);
+  pythia.setResonancePtr(resonanceTheta);
+
+  // Create instance of a class to generate the q qbar -> Theta process 
+  // from an external matrix element. Hand in pointer to Pythia.  
+  SigmaProcess* sigma1Theta = new Sigma1qqbar2Theta();
+  pythia.setSigmaPtr(sigma1Theta);
+
+  // Optionally only compare cross sections.
+  //pythia.readString("PartonLevel:all = off");
+  pythia.readString("Check:nErrList = 2");
+
+  // Initialization for LHC.
+  pythia.init( 2212, 2212, 14000.);
+
+  // List changed settings and Theta particle data.
+  pythia.settings.listChanged();
+  pythia.particleData.list(663);
+
+  // Book histogram.
+  Hist mTheta("Theta mass", 100, 300., 400.);
+
+  // Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) cout << " Now begin event " 
+      << iEvent << endl;
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+      pythia.event.list();
+    }
+
+    // Fill Theta mass. End of event loop.
+    mTheta.fill( pythia.process[5].m() );
+  }
+
+  // Final statistics. Print histogram.
+  pythia.statistics();
+  cout << mTheta;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main27.cc b/PYTHIA8/pythia8145/examples/main27.cc
new file mode 100644 (file)
index 0000000..d479374
--- /dev/null
@@ -0,0 +1,242 @@
+// main27.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Example how to write a derived class for beam momentum and vertex spread,
+// with an instance handed to Pythia for internal generation.
+// Warning: the parameters are not realistic. 
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+//==========================================================================
+
+// A derived class to set beam momentum and interaction vertex spread.
+
+class MyBeamShape : public BeamShape {
+
+public:
+
+  // Constructor.
+  MyBeamShape() {}
+
+  // Initialize beam parameters.
+  // In this particular example we will reuse the existing settings names
+  // but with modified meaning, so init() in the base class can be kept. 
+  //virtual void init( Settings& settings, Rndm* rndmPtrIn);
+
+  // Set the two beam momentum deviations and the beam vertex.
+  virtual void pick();
+
+};
+
+//--------------------------------------------------------------------------
+
+// Set the two beam momentum deviations and the beam vertex.
+// Note that momenta are in units of GeV and vertices in mm,
+// always with c = 1, so that e.g. time is in mm/c. 
+
+void MyBeamShape::pick() {
+
+  // Reset all values.
+  deltaPxA = deltaPyA = deltaPzA = deltaPxB = deltaPyB = deltaPzB
+    = vertexX = vertexY = vertexZ = vertexT = 0.;
+
+  // Set beam A transverse momentum deviation by a two-dimensional Gaussian.
+  if (allowMomentumSpread) {
+    double totalDev, gauss;
+    do {
+      totalDev = 0.;
+      if (sigmaPxA > 0.) {
+        gauss     = rndmPtr->gauss();
+        deltaPxA  = sigmaPxA * gauss;
+        totalDev += gauss * gauss; 
+      }
+      if (sigmaPyA > 0.) {
+        gauss     = rndmPtr->gauss();
+        deltaPyA  = sigmaPyA * gauss;
+        totalDev += gauss * gauss; 
+      }
+    } while (totalDev > maxDevA * maxDevA); 
+
+    // Set beam A longitudinal momentum as a triangular shape.
+    // Reuse sigmaPzA to represent maximum deviation in this case.
+    if (sigmaPzA > 0.) {
+      deltaPzA    = sigmaPzA * ( 1. - sqrt(rndmPtr->flat()) );
+      if (rndmPtr->flat() < 0.5) deltaPzA = -deltaPzA; 
+    }
+
+    // Set beam B transverse momentum deviation by a two-dimensional Gaussian.
+    do {
+      totalDev = 0.;
+      if (sigmaPxB > 0.) {
+        gauss     = rndmPtr->gauss();
+        deltaPxB  = sigmaPxB * gauss;
+        totalDev += gauss * gauss; 
+      }
+      if (sigmaPyB > 0.) {
+        gauss     = rndmPtr->gauss();
+        deltaPyB  = sigmaPyB * gauss;
+        totalDev += gauss * gauss; 
+      }
+    } while (totalDev > maxDevB * maxDevB); 
+
+    // Set beam B longitudinal momentum as a triangular shape.
+    // Reuse sigmaPzB to represent maximum deviation in this case.
+    if (sigmaPzB > 0.) {
+      deltaPzB = sigmaPzB * ( 1. - sqrt(rndmPtr->flat()) );
+      if (rndmPtr->flat() < 0.5) deltaPzB = -deltaPzB; 
+    }
+  }
+
+  // Set beam vertex location by a two-dimensional Gaussian.
+  if (allowVertexSpread) {
+    double totalDev, gauss;
+    do {
+      totalDev = 0.;
+      if (sigmaVertexX > 0.) {
+        gauss     = rndmPtr->gauss();
+        vertexX   = sigmaVertexX * gauss;
+        totalDev += gauss * gauss; 
+      }
+      if (sigmaVertexY > 0.) {
+        gauss     = rndmPtr->gauss();
+        vertexY   = sigmaVertexY * gauss;
+        totalDev += gauss * gauss; 
+      }
+    } while (totalDev > maxDevVertex * maxDevVertex);
+
+    // Set beam B longitudinal momentum as a triangular shape.
+    // This corresponds to two step-function beams colliding.
+    // Reuse sigmaVertexZ to represent maximum deviation in this case.
+    if (sigmaVertexZ > 0.) {
+      vertexZ     = sigmaVertexZ * ( 1. - sqrt(rndmPtr->flat()) );
+      if (rndmPtr->flat() < 0.5) vertexZ = -vertexZ; 
+
+      // Set beam collision time flat between +-(sigmaVertexZ - |vertexZ|). 
+      // This corresponds to two step-function beams colliding (with v = c).
+      vertexT = (2. * rndmPtr->flat() - 1.) * (sigmaVertexZ - abs(vertexZ));  
+    }
+
+    // Add offset to beam vertex.
+    vertexX      += offsetX;
+    vertexY      += offsetY;
+    vertexZ      += offsetZ;
+    vertexT      += offsetT;
+  }  
+
+}
+//==========================================================================
+
+int main() {
+
+  // Number of events to generate and to list. Max number of errors.
+  int nEvent = 10000;
+  int nList  = 1;
+  int nAbort = 5;
+
+  // Pythia generator.
+  Pythia pythia;
+
+  // Process selection.
+  pythia.readString("HardQCD:all = on");    
+  pythia.readString("PhaseSpace:pTHatMin = 20."); 
+
+  // LHC with acollinear beams in the x plane.
+  // Use that default is pp with pz = +-7000 GeV, so this need not be set.  
+  pythia.readString("Beams:frameType = 3");    
+  pythia.readString("Beams:pxA = 1.");    
+  pythia.readString("Beams:pxB = 1.");  
+
+  // A class to generate beam parameters according to own parametrization.
+  BeamShape* myBeamShape = new MyBeamShape();
+
+  // Hand pointer to Pythia. 
+  // If you comment this out you get internal Gaussian-style implementation.
+  pythia.setBeamShapePtr( myBeamShape);
+
+  // Set up beam spread parameters - reused by MyBeamShape.  
+  pythia.readString("Beams:allowMomentumSpread = on");  
+  pythia.readString("Beams:sigmapxA = 0.1");  
+  pythia.readString("Beams:sigmapyA = 0.1");  
+  pythia.readString("Beams:sigmapzA = 5.");  
+  pythia.readString("Beams:sigmapxB = 0.1");  
+  pythia.readString("Beams:sigmapyB = 0.1");  
+  pythia.readString("Beams:sigmapzB = 5."); 
+
+  // Set up beam vertex parameters - reused by MyBeamShape.
+  pythia.readString("Beams:allowVertexSpread = on");  
+  pythia.readString("Beams:sigmaVertexX = 0.3");  
+  pythia.readString("Beams:sigmaVertexY = 0.3");  
+  pythia.readString("Beams:sigmaVertexZ = 50.");  
+  // In MyBeamShape the time width is not an independent parameter.
+  //pythia.readString("Beams:sigmaTime = 50.");  
+
+  // Optionally simplify generation.
+  pythia.readString("PartonLevel:all = off");  
+
+  // Initialization.  
+  pythia.init();
+
+  // Read out nominal energy.
+  double eCMnom = pythia.info.eCM(); 
+
+  // Histograms.
+  Hist eCM("center-of-mass energy deviation", 100, -20., 20.);
+  Hist pXsum("net pX offset", 100, -1.0, 1.0);
+  Hist pYsum("net pY offset", 100, -1.0, 1.0);
+  Hist pZsum("net pZ offset", 100, -10., 10.);
+  Hist pZind("individual abs(pZ) offset", 100, -10., 10.);
+  Hist vtxX("vertex x position", 100, -1.0, 1.0);
+  Hist vtxY("vertex y position", 100, -1.0, 1.0);
+  Hist vtxZ("vertex z position", 100, -100., 100.);
+  Hist vtxT("vertex time", 100, -100., 100.);
+  Hist vtxZT("vertex |x| + |t|", 100, 0., 100.);
+
+  // Begin event loop. Generate event. 
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (!pythia.next()) {
+
+      // List faulty events and quit if many failures.
+      pythia.info.list(); 
+      pythia.process.list();
+      //pythia.event.list();
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;      
+    }
+    // List first few events.
+    if (iEvent < nList) { 
+      pythia.info.list(); 
+      pythia.process.list(); 
+      //pythia.event.list();
+    } 
+
+    // Fill histograms.
+    double eCMnow = pythia.info.eCM();
+    eCM.fill( eCMnow - eCMnom);
+    pXsum.fill(  pythia.process[0].px() - 2. );
+    pYsum.fill(  pythia.process[0].py() );
+    pZsum.fill(  pythia.process[0].pz() );
+    pZind.fill(  pythia.process[1].pz() - 7000. );
+    pZind.fill( -pythia.process[2].pz() - 7000. );
+    vtxX.fill(  pythia.process[0].xProd() );
+    vtxY.fill(  pythia.process[0].yProd() );
+    vtxZ.fill(  pythia.process[0].zProd() );
+    vtxT.fill(  pythia.process[0].tProd() );
+    double absSum = abs(pythia.process[0].zProd()) 
+                  + abs(pythia.process[0].tProd());
+    vtxZT.fill( absSum );
+
+  // End of event loop. Statistics. Histograms. Done.
+  }
+  pythia.statistics();
+  cout << eCM << pXsum << pYsum << pZsum << pZind
+       << vtxX << vtxY << vtxZ << vtxT << vtxZT; 
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main28.cc b/PYTHIA8/pythia8145/examples/main28.cc
new file mode 100644 (file)
index 0000000..21b12c0
--- /dev/null
@@ -0,0 +1,212 @@
+// main28.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// This is a test program for the extra dimensions processes.
+// Author: Stefan Ask (Stefan DOT Ask AT cern DOT ch)
+// Documentation: S. Ask et al., arXiv:0809.4750 and arXiv:0912.4233
+
+#include "Pythia.h"
+
+using namespace Pythia8; 
+
+//+++ The main program.
+int main() {
+
+  //+++ Test cases
+  //+++ 1  = Jet + G       (real G emission) 
+  //+++ 2  = Jet + U       (real U emission) 
+  //+++ 3  = Z + G         (real G emission) 
+  //+++ 4  = Z + U         (real U emission)
+  //+++ 5  = gamma gamma   (LED G* exchange)
+  //+++ 6  = l lbar        (LED U* exchange). 
+  //+++      Note: charged leptons only!
+  //+++ 7  = Z_KK/gamma_KK (TEV ED resonance) 
+  //+++ 8  = G*            (RS resonance, SM on the TeV brane)
+  //+++ 9  = kk-gluon*     (RS resonance)
+  int nTest = 1;  
+
+  //+++ Number of events to generate and to list. Max number of errors.
+  int nEvent     = 100;      
+  int nList      = 1;       
+  int nAbort     = 50;         
+
+  //+++ Pythia generator.
+  Pythia pythia;
+
+  //+++ PYTHIA paramters:
+  pythia.readString("PhaseSpace:showViolation = off");
+
+  //+++ Test case parameters
+  if (nTest == 1) { 
+    pythia.readString("ExtraDimensionsLED:monojet = on");
+    pythia.readString("ExtraDimensionsLED:n = 4");
+    pythia.readString("ExtraDimensionsLED:MD = 4000.");
+    pythia.readString("ExtraDimensionsLED:CutOffmode = 3");
+    pythia.readString("ExtraDimensionsLED:t = 2");
+    pythia.readString("5000039:m0 = 2500.");
+    pythia.readString("5000039:mWidth = 1500.");
+    pythia.readString("5000039:mMin = 1.");
+    pythia.readString("5000039:mMax = 13990.");
+    pythia.readString("PhaseSpace:pTHatMin = 700.");
+  } else if (nTest == 2){ 
+    pythia.readString("ExtraDimensionsUnpart:gg2Ug = off");
+    pythia.readString("ExtraDimensionsUnpart:qg2Uq = on");
+    pythia.readString("ExtraDimensionsUnpart:qqbar2Ug = on");
+    pythia.readString("ExtraDimensionsUnpart:spinU = 1");
+    pythia.readString("ExtraDimensionsUnpart:dU = 1.2");
+    pythia.readString("ExtraDimensionsUnpart:LambdaU = 1000");
+    pythia.readString("ExtraDimensionsUnpart:lambda = 1.0");
+    pythia.readString("ExtraDimensionsUnpart:CutOffmode = 0");
+    pythia.readString("5000039:m0 = 300.");
+    pythia.readString("5000039:mWidth = 500.");
+    pythia.readString("5000039:mMin = 1.");
+    pythia.readString("5000039:mMax = 13990.");
+    pythia.readString("PhaseSpace:pTHatMin = 700.");
+  } else if (nTest == 3){
+    pythia.readString("ExtraDimensionsLED:ffbar2GZ = on");
+    pythia.readString("ExtraDimensionsLED:n = 6");
+    pythia.readString("ExtraDimensionsLED:MD = 2000.");
+    pythia.readString("ExtraDimensionsLED:CutOffmode = 1");
+    pythia.readString("5000039:m0 = 3000.");
+    pythia.readString("5000039:mWidth = 1500.");
+    pythia.readString("5000039:mMin = 1.");
+    pythia.readString("5000039:mMax = 13990.");
+    pythia.readString("PhaseSpace:pTHatMin = 50.");
+  } else if (nTest == 4){ 
+    pythia.readString("ExtraDimensionsUnpart:ffbar2UZ = on");
+    pythia.readString("ExtraDimensionsUnpart:spinU = 1");
+    pythia.readString("ExtraDimensionsUnpart:dU = 2.0");
+    pythia.readString("ExtraDimensionsUnpart:LambdaU = 1000");
+    pythia.readString("ExtraDimensionsUnpart:lambda = 1.000");
+    pythia.readString("ExtraDimensionsUnpart:CutOffmode = 0");
+    pythia.readString("5000039:m0 = 500.");
+    pythia.readString("5000039:mWidth = 1000.");
+    pythia.readString("5000039:mMin = 1.");
+    pythia.readString("5000039:mMax = 13990.");
+    pythia.readString("PhaseSpace:pTHatMin = 50.");
+  } else if (nTest == 5){ 
+    pythia.readString("ExtraDimensionsLED:ffbar2gammagamma = on");
+    pythia.readString("ExtraDimensionsLED:gg2gammagamma = on");
+    pythia.readString("ExtraDimensionsLED:LambdaT = 3300.");
+    pythia.readString("PhaseSpace:mHatMin = 800.");
+  } else if (nTest == 6){ 
+    pythia.readString("ExtraDimensionsUnpart:ffbar2llbar = on");
+    pythia.readString("ExtraDimensionsUnpart:gg2llbar = off");
+    pythia.readString("ExtraDimensionsUnpart:spinU = 1");
+    pythia.readString("ExtraDimensionsUnpart:dU = 1.3");
+    pythia.readString("ExtraDimensionsUnpart:LambdaU = 1000");
+    pythia.readString("ExtraDimensionsUnpart:lambda = 1.0");
+    pythia.readString("ExtraDimensionsUnpart:gXX = 0");
+    pythia.readString("ExtraDimensionsUnpart:gXY = 0");
+    pythia.readString("PhaseSpace:mHatMin = 300.");
+  } else if (nTest == 7){
+    pythia.readString("ExtraDimensionsTEV:ffbar2ffbar = on");
+    pythia.readString("ExtraDimensionsTEV:gmZmode = 3"); 
+    pythia.readString("ExtraDimensionsTEV:nMax = 100"); 
+    pythia.readString("ExtraDimensionsTEV:mStar = 4000");
+    pythia.readString("PhaseSpace:mHatMin = 1000");
+    pythia.readString("PhaseSpace:mHatMax = 6000");
+    pythia.readString("5000023:isResonance = false");
+  } else if (nTest == 8){
+    pythia.readString("ExtraDimensionsG*:all = on");
+  } else if (nTest == 9){
+    pythia.readString("ExtraDimensionsG*:qqbar2KKgluon* = on");
+    pythia.readString("ExtraDimensionsG*:KKintMode = 2");
+    pythia.readString("ExtraDimensionsG*:KKgqR = -0.2");
+    pythia.readString("ExtraDimensionsG*:KKgqL = -0.2");
+    pythia.readString("ExtraDimensionsG*:KKgbR = -0.2");
+    pythia.readString("ExtraDimensionsG*:KKgbL = 1.0");
+    pythia.readString("ExtraDimensionsG*:KKgtR = 5.0");
+    pythia.readString("ExtraDimensionsG*:KKgtL = 1.0");
+    pythia.readString("5100021:m0 = 2000");
+  }
+
+  //+++ Initialization for LHC.
+  pythia.init( 2212, 2212, 14000.);
+
+  //+++ Validation histograms
+  Hist hEtjet("dN/dETjet", 100, 0., 7000.);
+  Hist hMass("dN/m", 100, 0., 7000.);
+
+  //+++ Begin event loop.
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (iEvent%(max(1,nEvent/20)) == 0) std::cout << " Now begin event " 
+                                                 << iEvent << "\n";
+    
+    //+++ Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      std::cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    //+++ List first few events. 
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.process.list();
+    }
+
+    //+++ Checked particle index
+    int tmp_monojet = -1;
+
+    //+++ Particle loop
+    for (int iPart = 0; iPart < pythia.event.size(); ++iPart) {
+
+      //+++ From hard process (inital = 21, interm.=22, final=23 state)
+      if (pythia.event[iPart].statusAbs()  == 22) {
+
+       //+++ Find Z_KK/gamma_KK or kk-gluon
+       if( pythia.event[iPart].idAbs() == 5000023 
+        || pythia.event[iPart].idAbs() == 5100021
+        || pythia.event[iPart].idAbs() == 5100039){
+         hMass.fill( pythia.event[iPart].m() );
+       }
+       
+      }        else if ( pythia.event[iPart].statusAbs()  == 23 ) {
+       
+       //+++ Find graviton/unparticle
+       if( pythia.event[iPart].idAbs() == 5000039){
+         hMass.fill( pythia.event[iPart].m() );
+       }
+
+       //+++ Find mono-jets
+       if (nTest == 1 || nTest == 2) {
+         if ( pythia.event[iPart].idAbs() <= 6 
+            || pythia.event[iPart].idAbs() == 21 ){
+           if (tmp_monojet >= 0) {
+             std::cout << "More than one (hard process) mono-jet ! \n";
+           } else {
+             tmp_monojet  = iPart;
+           }
+         }
+       }
+
+      }
+    }
+
+    //+++ Validation mono-jet wrt G.Giudice et al. paper [hep-ph/9811291v2]    
+    if (tmp_monojet >= 0) {
+      double tmp_eta = pythia.event[tmp_monojet].eta();
+      double tmp_et = pythia.event[tmp_monojet].eT();
+      double tmp_et_cut = 1000;
+      if ( tmp_et >=  tmp_et_cut && abs(tmp_eta) < 3 ) {
+       hEtjet.fill( fabs(tmp_et) );
+      }    
+    }
+    
+  }  
+  //+++ Final statistics.
+  pythia.statistics(); 
+
+  std::cout << "-------------- Graviton mass  ------------" << "\n";
+  std::cout << hMass;
+  std::cout << "-------------- Mono-jet check ------------" << "\n";
+  std::cout << hEtjet;
+  std::cout << "------------------------------------------" << "\n";
+
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main29.cc b/PYTHIA8/pythia8145/examples/main29.cc
new file mode 100644 (file)
index 0000000..0112f09
--- /dev/null
@@ -0,0 +1,125 @@
+// main29.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// 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.
+
+#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("main29.cmnd");
+
+  // Initialization.
+  pythia.init();
+
+  // Extract settings to be used in the main program.
+  int    nEvent  = pythia.mode("Main:numberOfEvents");
+  int    nList   = pythia.mode("Main:numberToList");
+  int    nShow   = pythia.mode("Main:timesToShow");
+  int    nAbort  = pythia.mode("Main:timesAllowErrors");
+  bool   showCS  = pythia.flag("Main:showChangedSettings");
+  bool   showCPD = pythia.flag("Main:showChangedParticleData");
+
+  // List changes.
+  if (showCS)  pythia.settings.listChanged();
+  if (showCPD) pythia.particleData.listChanged();
+
+  // 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 nPace  = max(1, nEvent / max(1, nShow) ); 
+  int iAbort = 0;
+  for (int iEvent = 0; iEvent < nEvent; ++iEvent) {
+    if (nShow > 0 && iEvent%nPace == 0) 
+      cout << " Now begin event " << iEvent << endl;
+
+    // Generate events. Quit if many failures.
+    if (!pythia.next()) {
+      if (++iAbort < nAbort) continue;
+      cout << " Event generation aborted prematurely, owing to error!\n"; 
+      break;
+    }
+    // List first few events.
+    if (iEvent < nList) { 
+      pythia.info.list();
+      pythia.event.list();
+    }
+
+    // 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.statistics();
+  cout << eGamma << eE << eP << eNu << eRest;
+
+  // Done.
+  return 0;
+}
diff --git a/PYTHIA8/pythia8145/examples/main29.cmnd b/PYTHIA8/pythia8145/examples/main29.cmnd
new file mode 100644 (file)
index 0000000..e76738a
--- /dev/null
@@ -0,0 +1,36 @@
+! main29.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:numberToList = 1              ! number of events to print
+Main:timesToShow = 20              ! show how far along run is
+Main:timesAllowErrors = 5          ! allow a few failures before quitting
+Main:showChangedSettings = on      ! print changed flags/modes/parameters
+Main:showChangedParticleData = on  ! print changed particle and decay data
+
+! 2) 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
+
+! 3) 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
+
+! 4) 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/pythia8145/examples/main30.cc b/PYTHIA8/pythia8145/examples/main30.cc
new file mode 100644 (file)
index 0000000..cb946ce
--- /dev/null
@@ -0,0 +1,128 @@
+// main30.cc is a part of the PYTHIA event generator.
+// Copyright (C) 2010 Torbjorn Sjostrand.
+// PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
+// Please respect the MCnet Guidelines, see GUIDELINES for details.
+
+// Kaluza-Klein gamma*/Z resonances in TeV-sized extra dimensions.
+
+#include <assert.h>
+#include <time.h>
+#include <sstream>
+
+#include "Pythia.h"
+using namespace Pythia8; 
+
+int main() {
+
+  // Generator.
+  Pythia pythia;
+  ParticleData& pdt = pythia.particleData;
+
+  // Pick new random number seed for each run, based on clock.
+  pythia.readString("Random:setSeed = on");
+  pythia.readString("Random:seed = 0");
+  // Process selection.
+  pythia.readString("ExtraDimensionsTEV:ffbar2ffbar = on");
+
+  // Pick KK mass.  
+  double newMass = 4000.; // GeV
+  cout << "|-------------------------" << endl;
+  cout << "| KK mass is: " << newMass << endl;
+  cout << "|-------------------------" << endl;
+  stringstream strm;
+  string sNewMass, sNewWidth, sNewLowBound, sNewHighBound;
+
+  // Manually set the mass and therefore the width 
+  // and the phase space for the sampling
+  strm.clear();
+  strm << newMass;
+  strm >> sNewMass;
+  strm.clear();
+  strm << newMass / pdt.m0(5000023) * pdt.mWidth(5000023);
+  strm >> sNewWidth;
+  strm.clear();
+  strm << newMass/4.;
+  strm >> sNewLowBound;
+  strm.clear();
+  strm << newMass*2.;
+  strm >> sNewHighBound;
+
+  // Feed in KK state information and other generation specifics.  
+  pythia.readString("5000023:m0 = " + sNewMass);
+  pythia.readString("5000023:mWidth = " + sNewWidth);
+  pythia.readString("5000023:mMin = " + sNewLowBound);
+  pythia.readString("5000023:mMax = " + sNewHighBound);
+  pythia.readString("5000023:isResonance = false");
+  pythia.readString("ExtraDimensionsTEV:gmZmode = 3"); // 0=(gm+Z), 1=(gm), 2=(Z), 3=(gm+Z+gmKK+ZKK), 4=(m+Z+gmKK), 5=(m+Z+ZKK)
+  pythia.readString("ExtraDimensionsTEV:nMax = 100"); // min=0, max=100, default=10
+  pythia.readString("ExtraDimensionsTEV:mStar = " + sNewMass);
+  pythia.readString("PhaseSpace:mHatMin = " + sNewLowBound);
+  pythia.readString("PhaseSpace:mHatMax = " + sNewHighBound);
+
+  // Initialize.
+  pythia.init( 2212, 2212, 14000.);
+
+  // Histograms.
+  Hist mHatHisto("dN/dmHat", 50, newMass/4., newMass*2.);
+  Hist pTmuHisto("(dN/dpT)_mu^-", 50, 1., 2501.);
+
+  vector<int> moms;
+  
+  // Measure the cpu runtime,
+  clock_t start, stop;
+  double t = 0.0;
+  // Depending on operating system, either of lines below gives warning.
+  assert((start = clock()) != -1); // Start timer; clock_t signed.
+  //assert((start = clock()) != -1u); // Start timer; clock_t unsigned.
+  
+  // Begin event loop. Generate event. Skip if error. List first one.
+  for (int iEvent=0 ; iEvent<500 ; ++iEvent) {
+    if (!pythia.next()) continue;
+    if (iEvent < 1) {pythia.info.list(); pythia.event.list();}
+
+    // Begin event analysis.
+    bool isZ = false;
+    bool ismu = false;
+    int iZ = 0;
+    int imu = 0;
+    for (int i=0 ; i<pythia.event.size() ; ++i) {
+      // find the most recent Z
+      if (pythia.event[i].id()==5000023) {
+        iZ = i;
+        isZ = true;
+      }
+      // find the final muon who's first mother is the Z
+      if (pythia.event[i].id()==13 && pythia.event[i].isFinal()) {