NCFS-Pack
A generic (astro)particle physics analysis framework
 
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
NcCollider Class Reference

Pythia based universal (astro)physics event generator. More...

#include "NcCollider.h"

Inheritance diagram for NcCollider:

Detailed Description

Pythia based universal (astro)physics event generator.

Copyright(c) 2002 NCFS/IIHE, All Rights Reserved. *
*
Authors: The Netherlands Center for Fundamental Studies (NCFS). *
The Inter-university Institute for High Energies (IIHE). *
Website : http://www.iihe.ac.be *
Contact : Nick van Eijndhoven (nickve.nl@gmail.com) *
*
Contributors are mentioned in the code where appropriate. *
*
No part of this software may be used, copied, modified or distributed *
by any means nor transmitted or translated into machine language for *
commercial purposes without written permission by the IIHE representative. *
Permission to use the software strictly for non-commercial purposes *
is hereby granted without fee, provided that the above copyright notice *
appears in all copies and that both the copyright notice and this *
permission notice appear in the supporting documentation. *
This software is provided "as is" without express or implied warranty. *
The authors make no claims that this software is free of error, or is *
consistent with any particular standard of merchantability, or that it *
will meet your requirements for any particular application, other than *
indicated in the corresponding documentation. *
This software should not be relied on for solving a problem whose *
incorrect solution could result in injury to a person or loss of property. *
If you do use this software in such a manner, it is at your own risk. *
The authors disclaim all liability for direct or consequential damage *
resulting from your use of this software. *
// Class NcCollider
// Pythia based universal (astro)physics event generator.
// This class is derived from TPythia6 and has some extensions to
// support also generation of nucleus-nucleus interactions and to allow
// investigation of the effect of detector resolving power.
// Furthermore, the produced event information is provided in a format
// using the NcEvent structure.
// For the produced NcTrack objects, the particle ID code is set to the
// Pythia KF value, which is compatible with the PDG identifier.
// This will allow a direct analysis of the produced data using the
// NCFSPack physics analysis tools.
//
// For further details concerning the produced output structure,
// see the docs of the memberfunctions SetVertexMode and SetResolution.
//
// This NcCollider class also provides a facility to model c.q. perform the
// analysis of particle production via a combination of p+p and p+gamma processes,
// which for instance may be induced by the jet of a dust obscured AGN.
// For worked out examples, please refer to the macros "agn-model.cc"
// and "agn-analysis.cc" in the folder "/ncfs/physics/macros".
//
// Example job of minimum biased Pb+Pb interactions :
// --------------------------------------------------
// {
// gSystem->Load("libEG");
// gSystem->Load("libEGPythia6");
// gSystem->Load("ncfspack");
//
// NcCollider* gen=new NcCollider();
//
// gen->SetOutputFile("test.ncfspack");
// gen->SetVertexMode(3);
// gen->SetResolution(1e-6); // 1 micron vertex resolution
//
// gen->SetRunNumber(1);
//
// Int_t zp=82;
// Int_t ap=208;
// Int_t zt=82;
// Int_t at=208;
//
// gen->Init("fixt",zp,ap,zt,at,158);
//
// gen->SetTitle("SPS Pb-Pb collision at 158A GeV/c beam energy");
//
// Int_t nevents=5;
//
// NcRandom rndm;
// Float_t* rans=new Float_t[nevents];
// rndm.Uniform(rans,nevents,2,ap+at);
// Int_t npart;
// for (Int_t i=0; i<nevents; i++)
// {
// npart=rans[i];
// gen->MakeEvent(npart);
//
// NcEvent* evt=gen->GetEvent();
//
// evt->List();
// }
//
// gen->EndRun();
// }
//
//
// Example job of a pbar+p collider with both full NcEvent and selected plain ROOT Tree output.
// --------------------------------------------------------------------------------------------
// {
// gSystem->Load("libEG");
// gSystem->Load("libEGPythia6");
// gSystem->Load("ncfspack");
//
// NcCollider* gen=new NcCollider();
//
// NcTreeMaker* mktree=0;
// mktree=gen->SetOutputFile("test",2);
//
// if (mktree)
// {
// mktree->Select("event","jrun");
// mktree->Select("event","jevt");
// mktree->Select("event","user","BeamP");
// mktree->Select("event","user","BeamTheta");
// mktree->Select("event","user","BeamPhi");
// mktree->Select("event","user","TargetP");
// mktree->Select("event","user","TargetTheta");
// mktree->Select("event","user","TargetPhi");
//
// mktree->Select("track","p");
//
// mktree->UseTracks("e-");
// mktree->UseTracks("pi-");
// }
//
// gen->SetRunNumber(1);
//
// gen->Init("cms","pbar","p",2000);
//
// gen->SetTitle("pbar-p collider at 2 TeV");
//
// gen->SetPrintFreq(10);
//
// Int_t nevents=100;
//
// for (Int_t i=0; i<nevents; i++)
// {
// gen->MakeEvent();
// }
//
// gen->EndRun();
// }
//
// Example job of a cosmic nu+p atmospheric interaction.
// -----------------------------------------------------
// {
// gSystem->Load("libEG");
// gSystem->Load("libEGPythia6");
// gSystem->Load("ncfspack");
//
// NcCollider* gen=new NcCollider();
//
// gen->SetOutputFile("test.ncfspack");
//
// gen->SetRunNumber(1);
//
// gen->Init("fixt","nu_mu","p",1e11);
//
// gen->SetTitle("Atmospheric nu_mu-p interaction at 1e20 eV");
//
// Int_t nevents=10;
//
// for (Int_t i=0; i<nevents; i++)
// {
// gen->MakeEvent(0,1);
//
// NcEvent* evt=gen->GetEvent();
//
// evt->Data();
// }
//
// gen->EndRun();
// }
//
// Example job for astrophyical (obscured) AGN Jet modeling with selected plain ROOT Tree output.
// ----------------------------------------------------------------------------------------------
// {
// gSystem->Load("libEG");
// gSystem->Load("libEGPythia6");
// gSystem->Load("ncfspack");
//
// NcCollider* gen=new NcCollider();
// gen->SetTitle("Astrophysical (obscured) AGN Jet modeling");
//
// gen->SetOutputFile("agn-jet.root",1);
//
// Float_t np=1000; // Number of Jet (beam) protons to be simulated
// Float_t gfrac=0.2; // Fraction of Jet (beam) protons used for p+gamma interactions
// TString flux="nu,neutron,gamma"; // The final particle species that will be recorded
// Float_t dthmax=-1; // Variation in target momentum theta direction (in degrees)
// Int_t nlist=1; // Produce an event listing of the first "nlist" events of each sample
//
// Int_t mult=1; // Flag to indicate activation of multiple partonic interactions
// Int_t elastic=0; // Flag to indicate activation of Low-Pt, Elastic and Diffractive interactions
//
// // Specification of the proton (beam) spectrum
// Double_t pmin=1e5;
// Double_t pmax=1e7;
// TF1 fp("fp","pow(x,-2)");
// gen->SetJetProtonSpectrum(pmin,pmax,&fp);
//
// // Specification of the gamma (target) spectrum
// pmin=1e-4;
// pmax=1e-3;
// TF1 fg("fg","pow(x,-3)");
// gen->SetJetGammaSpectrum(pmin,pmax,&fg);
//
// gen->SetPrintFreq(50);
// gen->SetMultiple(mult);
// gen->SetElastic(elastic);
// gen->ProcessJet(np,gfrac,flux,dthmax,nlist);
// }
//
//
//--- Author: Nick van Eijndhoven 22-nov-2002 Utrecht University
//- Modified: Nick van Eijndhoven, IIHE-VUB, Brussel, May 12, 2023 12:54Z

Definition at line 20 of file NcCollider.h.

Public Member Functions

 NcCollider ()
 
virtual ~NcCollider ()
 
void EndRun ()
 
Double_t GetEcmsMin () const
 
Int_t GetElastic () const
 
NcEvent * GetEvent (Int_t select=0) const
 
TH1 * GetJetGammaSpectrum (Double_t *pmin=0, Double_t *pmax=0)
 
TH1 * GetJetProtonSpectrum (Double_t *pmin=0, Double_t *pmax=0)
 
Int_t GetMultiple () const
 
Int_t GetPrintFreq () const
 
Int_t GetRandomSeed ()
 
Double_t GetResolution () const
 
Int_t GetRunNumber () const
 
Int_t GetSelectionFlag () const
 
Float_t GetSpectatorPmin () const
 
Int_t GetUserControl () const
 
Int_t GetVertexMode () const
 
Float_t GetWin () const
 
Int_t Init (TString frame, Int_t zp, Int_t ap, Int_t zt, Int_t at, Float_t win, Nc3Vector *pbeam=0, Nc3Vector *ptarget=0, Int_t wxsec=1)
 
Int_t Init (TString frame, TString beam, TString target, Float_t win, Nc3Vector *pbeam=0, Nc3Vector *ptarget=0, Int_t wxsec=1, Double_t fact=0)
 
Int_t MakeEvent (Int_t npt=0, Int_t mlist=-1, Int_t medit=1)
 
void ProcessJet (Double_t np, Double_t gfrac, TString flux, Double_t dthmax=0, Int_t nlist=1, Int_t ntrymax=1000, Int_t wxsec=0, Double_t finit=0, Int_t full=0)
 
void SelectEvent (Int_t id)
 
void SetEcmsMin (Double_t ecms)
 
void SetElastic (Int_t flag)
 
void SetJetGammaSpectrum (Double_t pmin, Double_t pmax=-1, TF1 *fspec=0, TH1 *hspec=0, Int_t mode=0)
 
void SetJetProtonSpectrum (Double_t pmin, Double_t pmax=-1, TF1 *fspec=0, TH1 *hspec=0, Int_t mode=0)
 
void SetMomentum (Nc3Vector &p, Int_t mode)
 
void SetMultiple (Int_t flag)
 
NcTreeMaker * SetOutputFile (TString fname, Int_t mode=0)
 
void SetPrintFreq (Int_t n)
 
void SetRandomSeed (Int_t iseed)
 
void SetResolution (Double_t res)
 
void SetRunNumber (Int_t run)
 
void SetSpectatorPmin (Float_t pmin)
 
void SetStable (Int_t id, Int_t mode=1, Int_t cls=0)
 
void SetUserControl (Int_t flag)
 
void SetVertexMode (Int_t mode)
 

Protected Member Functions

void GetFractions (Float_t zp, Float_t ap, Float_t zt, Float_t at)
 
TString GetPyname (Int_t kf)
 
Int_t IsSelected ()
 

Protected Attributes

Int_t fAproj
 
Int_t fAtarg
 
NcTrack fBeam
 
Double_t fEcmsmin
 
Int_t fElastic
 
NcEvent * fEvent
 
Int_t fEventnum
 
NcSignal fEvtuser
 
Float_t fFracnn
 
Float_t fFracnp
 
Float_t fFracpn
 
Float_t fFracpp
 
TString fFrame
 
Double_t fJetGpmax
 
Double_t fJetGpmin
 
Int_t fJetGscale
 
TH1 * fJetGspectrum
 
Double_t fJetPpmax
 
Double_t fJetPpmin
 
Int_t fJetPscale
 
TH1 * fJetPspectrum
 
NcJob * fJob
 
NcAstrolab fLab
 
NcBoost fLorbo
 
NcTreeMaker * fMktree
 
Int_t fMultiple
 
Int_t fNucl
 
TFile * fOutFile
 
TTree * fOutTree
 
Int_t fPrintfreq
 
NcRandom fRan
 
Double_t fResolution
 
Int_t fRunnum
 
Int_t fSelect
 
TArrayI * fSelections
 
Float_t fSpecpmin
 
NcTrack fTarget
 
Int_t fUserctrl
 
Int_t fVertexmode
 
Float_t fWin
 
Int_t fWxsec
 
Int_t fZproj
 
Int_t fZtarg
 

Constructor & Destructor Documentation

◆ NcCollider()

NcCollider::NcCollider ( )
// Default constructor.
// All variables initialised to default values.
//
// Some Pythia default MC parameters are automatically modified to provide
// more suitable running conditions for soft processes in view of
// nucleus-nucleus interactions and astrophysical processes.
// The user may initialise the generator with all the default Pythia
// parameters and obtain full user control to modify the settings by means
// of the SetUserControl memberfunction.
//
// Refer to the SetElastic memberfunction for the inclusion of elastic
// and diffractive processes.
// By default these processes are not included.

Definition at line 230 of file NcCollider.cxx.

◆ ~NcCollider()

NcCollider::~NcCollider ( )
virtual
// Default destructor.

Definition at line 307 of file NcCollider.cxx.

Member Function Documentation

◆ EndRun()

void NcCollider::EndRun ( )
// Properly flush last data to the output file(s) and close them.

Definition at line 2044 of file NcCollider.cxx.

◆ GetEcmsMin()

Double_t NcCollider::GetEcmsMin ( ) const
// Provide the minimal CMS energy (in GeV) for events to get generated.

Definition at line 715 of file NcCollider.cxx.

◆ GetElastic()

Int_t NcCollider::GetElastic ( ) const
// Provide the value of the control flag for elastic and diffractive processes.

Definition at line 661 of file NcCollider.cxx.

◆ GetEvent()

NcEvent * NcCollider::GetEvent ( Int_t select = 0) const
// Provide pointer to the generated event structure.
//
// select = 0 : Always return the pointer to the generated event.
// 1 : Only return the pointer to the generated event in case
// the event passed the selection criteria as specified via
// SelectEvent(). Otherwise the value 0 will be returned.
//
// By invoking GetEvent() the default of select=0 will be used.

Definition at line 2019 of file NcCollider.cxx.

◆ GetFractions()

void NcCollider::GetFractions ( Float_t zp,
Float_t ap,
Float_t zt,
Float_t at )
protected
// Determine the fractions for the various N-N collision processes.
// The various processes are : p+p, n+p, p+n and n+n.

Definition at line 1313 of file NcCollider.cxx.

◆ GetJetGammaSpectrum()

TH1 * NcCollider::GetJetGammaSpectrum ( Double_t * pmin = 0,
Double_t * pmax = 0 )
// Provide the gamma (target) spectrum of the Jet.
// The (optional) "pmin" and "pmax" will contain the momentum range in GeV/c,
// and in case this is not a mono-energetic gamma target, the return argument
// will contain the dN/dp spectrum in 1D histogram format.
// In case of a mono-energetic gamma target, the return argument will be zero.
//
// The default arguments are pmin=0 and pmax=0.

Definition at line 2633 of file NcCollider.cxx.

◆ GetJetProtonSpectrum()

TH1 * NcCollider::GetJetProtonSpectrum ( Double_t * pmin = 0,
Double_t * pmax = 0 )
// Provide the proton (beam) spectrum of the Jet.
// The (optional) "pmin" and "pmax" will contain the momentum range in GeV/c,
// and in case this is not a mono-energetic proton beam, the return argument
// will contain the dN/dp spectrum in 1D histogram format.
// In case of a mono-energetic proton beam, the return argument will be zero.
//
// The default arguments are pmin=0 and pmax=0.

Definition at line 2613 of file NcCollider.cxx.

◆ GetMultiple()

Int_t NcCollider::GetMultiple ( ) const
// Provide the value of the control flag for multiple interactions.

Definition at line 686 of file NcCollider.cxx.

◆ GetPrintFreq()

Int_t NcCollider::GetPrintFreq ( ) const
// Provide the user selected print frequency.

Definition at line 608 of file NcCollider.cxx.

◆ GetPyname()

TString NcCollider::GetPyname ( Int_t kf)
protected
// Provide the correctly truncated Pythia particle name for PGD code kf.
//
// The TPythia6::Pyname returned name is copied into a TString and truncated
// at the first blank to prevent funny trailing characters due to incorrect
// stripping of empty characters in TPythia6::Pyname.
// The truncation at the first blank is allowed due to the Pythia convention
// that particle names never contain blanks.

Definition at line 2331 of file NcCollider.cxx.

◆ GetRandomSeed()

Int_t NcCollider::GetRandomSeed ( )
// Provide the value of the current random number sequence seed.

Definition at line 761 of file NcCollider.cxx.

◆ GetResolution()

Double_t NcCollider::GetResolution ( ) const
// Provide the current resolution (in meter) for resolving (sec.) vertices.

Definition at line 561 of file NcCollider.cxx.

◆ GetRunNumber()

Int_t NcCollider::GetRunNumber ( ) const
// Provide the user defined run number.

Definition at line 584 of file NcCollider.cxx.

◆ GetSelectionFlag()

Int_t NcCollider::GetSelectionFlag ( ) const
// Return the value of the selection flag for the total event.
// When the event passed the selection criteria as specified via
// SelectEvent() the value 1 is returned, otherwise the value 0 is returned.

Definition at line 2248 of file NcCollider.cxx.

◆ GetSpectatorPmin()

Float_t NcCollider::GetSpectatorPmin ( ) const
// Provide the minimal spectator momentum in GeV/c.

Definition at line 2320 of file NcCollider.cxx.

◆ GetUserControl()

Int_t NcCollider::GetUserControl ( ) const
// Provide the value of the user control flag.

Definition at line 636 of file NcCollider.cxx.

◆ GetVertexMode()

Int_t NcCollider::GetVertexMode ( ) const
// Provide the current mode for vertex structure creation.

Definition at line 536 of file NcCollider.cxx.

◆ GetWin()

Float_t NcCollider::GetWin ( ) const
// Provide the value of the Pythia energy indicator (in GeV) used for initialisation.
// For regular frame="free" processing the value is set to -1, whereas a positive value
// indicates forced CMS processing. See Init() for further details.

Definition at line 773 of file NcCollider.cxx.

◆ Init() [1/2]

Int_t NcCollider::Init ( TString frame,
Int_t zp,
Int_t ap,
Int_t zt,
Int_t at,
Float_t win,
Nc3Vector * pbeam = 0,
Nc3Vector * ptarget = 0,
Int_t wxsec = 1 )
// Initialisation of the underlying Pythia generator package for the generation
// of nucleus-nucleus interactions.
// The event number is reset to 0.
//
// Input arguments :
// -----------------
// frame : "cms" --> Colliding beam experiment in the nucleon-nucleon CM frame (beam=+z, target=-z direction)
// "fixt" --> Fixed target experiment with beam in the +z direction
// "free" --> System defined by the user via "pbeam" and "ptarget"
// zp : Z value for the (Z,A) projectile nucleus
// ap : A value for the (Z,A) projectile nucleus
// zt : Z value for the (Z,A) target nucleus
// at : A value for the (Z,A) target nucleus
// win : Energy of the system depending on the frame specification.
// frame="cms" --> win is the total cms energy (in GeV) per nucleon-nucleon collision
// frame="fixt" --> win is the momentum (in GeV/c) per nucleon of the beam
// frame="free" --> win>=0 forces event generation in the nucleon-nucleon CMS followed by a Lorentz boost (using NcBoost)
// according to the user defined conditions via "pbeam" and "ptarget" (see below).
// For win>0 the nucleon-nucleon CM energy (Ecms) for cross section initialisations is set to the value of "win".
// For win=0 the Ecms for cross section initialisations is determined on basis of the specified
// "pbeam" and "ptarget".
// Note that events will always be generated according to the actual settings of "pbeam" and "ptarget".
// For very large boosts (e.g. Cosmic Ray physics above 10 PeV/c) the Pythia boost facility yields
// incorrect results due to accuracy issues. The more accurate NcBoost facility is used instead.
// This implies that for win>=0 the Pythia event data will reflect the situation in the nucleon-nucleon CM frame
// and that the event data in the user frame (defined via "pbeam" and "ptarget") is only available
// from the produced NcEvent structure (see memberfunction GetEvent) or the plain ROOT tree data.
// Due to internal Pythia accuracy issues it turns out that forcing the event generation
// in the CMS may also result in faster processing.
// In case win<0 it is a dummy parameter of which the value is irrelevant and the cross section
// initialisations are based on the settings of "pbeam" and "ptarget".
// pbeam : Beam 3-momentum in GeV/c per nucleon (only to be provided if frame="free").
// ptarget : Target 3-momentum in GeV/c per nucleon (only to be provided if frame="free").
// wxsec : Cross section weighting (1) or not (0) in the case frame="free".
// Weighting by cross section is necessary to obtain correct particle spectra when running
// at different energies within the same generation run via frame="free" and SetMomentum().
// The most accurate weighting is obtained by invoking this Init() function at the interaction
// energy with the highest cross section. In general this is just the highest foreseen energy
// (e.g. hadron-hadron interactions) or at some resonance (e.g. e+e- interactions).
// Note that with weighting sometimes no event is generated after invoking MakeEvent()
// to preserve the correct relative number of events for different energies.
// The information whether an event has been generated or not is indicated via the
// return argument of MakeEvent().
//
// By default pbeam=0, ptarget=0 and wxsec=1.
//
// Return value :
// --------------
// In case an error occurred, a value 1 will be returned. Otherwise the return value is 0.
//
// Some Pythia default MC parameters are automatically modified to provide
// more suitable running conditions for soft processes in view of
// nucleus-nucleus interactions and astrophysical processes.
//
// The optimisations consist of :
// ------------------------------
// * No minimum CMS energy is required for initialisation (see SetEcmsMin).
// * Activation of the default K factor values
// with separate settings for ordinary and color annihilation graphs.
// * Setting of the measured mass for the Higgs.
//
// The user may initialise the generator with all the default Pythia
// parameters and obtain full user control to modify the settings by means
// of invoking the SetUserControl memberfunction before this initialisation.
// Note that the inclusion of elastic and diffractive processes is controlled
// by invokation of the SetElastic memberfunction before this initialisation,
// irrespective of the UserControl selection. The same is true for the disabling
// of multiple interactions via the memberfunction SetMultiple.

Definition at line 1102 of file NcCollider.cxx.

◆ Init() [2/2]

Int_t NcCollider::Init ( TString frame,
TString beam,
TString target,
Float_t win,
Nc3Vector * pbeam = 0,
Nc3Vector * ptarget = 0,
Int_t wxsec = 1,
Double_t fact = 0 )
// Initialisation of the underlying Pythia generator package.
// The event number is reset to 0.
//
// Input arguments :
// -----------------
// frame : "cms" --> Colliding beam experiment in the CM frame (beam=+z, target=-z direction)
// "fixt" --> Fixed target experiment with beam in the +z direction
// "free" --> System defined by the user via "pbeam" and "ptarget"
// beam : Beam particle specification (see below).
// target : Target particle specification (see below).
// win : Energy of the system depending on the frame specification.
// frame="cms" --> win is the total cms energy in GeV
// frame="fixt" --> win is the beam particle momentum in GeV/c
// frame="free" --> win>=0 forces event generation in the CMS followed by a Lorentz boost (using NcBoost)
// according to the user defined conditions via "pbeam" and "ptarget" (see below).
// For win>0 the CM energy (Ecms) for cross section initialisations is set to the value of "win".
// Consequently, the use of the parameter "fact" (see below) is de-activated.
// For win=0 the Ecms for cross section initialisations is determined on basis of the specified
// "pbeam" and "ptarget" and the setting of "fact" is taken into account.
// Note that events will always be generated according to the actual settings of "pbeam" and "ptarget".
// For very large boosts (e.g. Cosmic Ray physics above 10 PeV/c) the Pythia boost facility yields
// incorrect results due to accuracy issues. The more accurate NcBoost facility is used instead.
// This implies that for win>=0 the Pythia event data will reflect the situation in the CM frame
// and that the event data in the user frame (defined via "pbeam" and "ptarget") is only available
// from the produced NcEvent structure (see memberfunction GetEvent) or the plain ROOT tree data.
// Due to internal Pythia accuracy issues it turns out that forcing the event generation
// in the CMS may also result in faster processing.
// In case win<0 it is a dummy parameter of which the value is irrelevant and the cross section
// initialisations are based on the settings of "pbeam" and "ptarget" with the setting of "fact"
// taken into account.
// pbeam : Beam particle 3-momentum in GeV/c (only to be provided if frame="free").
// ptarget : Target particle 3-momentum in GeV/c (only to be provided if frame="free").
// wxsec : Cross section weighting (1) or not (0) in the case frame="free".
// Weighting by cross section is necessary to obtain correct particle spectra when running
// at different energies within the same generation run via frame="free" and SetMomentum().
// The most accurate weighting is obtained by invoking this Init() function at the interaction
// energy with the highest cross section. In general this is just the highest foreseen energy
// (e.g. hadron-hadron interactions) or at some resonance (e.g. e+e- interactions).
// To use a certain interaction energy for cross section initialisations without changing the actual
// beam and/or target 3-momenta, please refer to the "fact" input argument outlined hereafter.
// Note that with weighting sometimes no event is generated after invoking MakeEvent()
// to preserve the correct relative number of events for different energies.
// The information whether an event has been generated or not is indicated via the
// return argument of MakeEvent().
// fact : Multiplication factor for the beam or target 3-momentum to be used for initialisation purposes
// (e.g. selection of processes and cross sections) only.
// Initialisation at a different interaction energy than the one corresponding to the specified
// beam and target 3-momenta might be needed as explained above, or to ensure activation of the
// relevant processes in case interactions are to be studied around threshold energies.
// The latter may save considerable cpu time at the event generation, since most of the phase space
// has been scanned already at the initialisation step.
// Note that also disabling multiple interactions via SetMultiple() may speed up the event generation
// significantly around threshold energies.
// The value of "fact" is only relevant when frame="free" and win<=0 (see above) are specified.
// fact=0 --> The provided beam and target 3-momenta are used for intialisation.
// fact>0 --> The beam 3-momentum is multiplied by the value of "fact" for intialisation.
// fact<0 --> The target 3-momentum is multiplied by the absolute value of "fact" for initialisation.
//
// By default pbeam=0, ptarget=0, wxsec=1 and fact=0.
//
// Return value :
// --------------
// In case an error occurred, a value 1 will be returned. Otherwise the return value is 0.
//
// For the beam and target particle specifications the following naming conventions are used :
//
// Leptons :
// ---------
// "e-", "e+", "mu-", "mu+", "tau-", "tau+", "nue", "numu", "nutau"
//
// Mesons :
// --------
// "pi+", "pi-", "pi0", "K+", "K-", "KS0", "KL0"
//
// Baryons :
// ---------
// "p", "n", "Lambda0", "Sigma+", "Sigma-", "Sigma0", "Xi-", "Xi0", "Omega-"
//
// (Virtual) Photons :
// -------------------
// "gamma" : Real photon
// "gamma/e-" : Virtual photon in an "e-" beam; "win" refers to the "e-" energy; not possible with frame="free"
// "gamma/e+" : Virtual photon in an "e+" beam; "win" refers to the "e+" energy; not possible with frame="free"
// "gamma/mu-" : Virtual photon in a "mu-" beam; "win" refers to the "mu-" energy; not possible with frame="free"
// "gamma/mu+" : Virtual photon in a "mu+" beam; "win" refers to the "mu+" energy; not possible with frame="free"
// "gamma/tau-" : Virtual photon in a "tau-" beam; "win" refers to the "tau-" energy; not possible with frame="free"
// "gamma/tau+" : Virtual photon in a "tau+" beam; "win" refers to the "tau+" energy; not possible with frame="free"
//
// Note : Anti-particles are specified by denoting "bar" at the end of the name.
// So, "pbar" for an anti-proton, "nuebar" for an electron anti-neutrino etc.
//
// Some Pythia default MC parameters are automatically modified to provide
// more suitable running conditions for soft processes in view of
// astrophysical processes.
//
// The optimisations consist of :
// ------------------------------
// * Usage of real photons for photon beams or targets
// * No minimum CMS energy is required for initialisation (see SetEcmsMin).
// * Activation of the default K factor values
// with separate settings for ordinary and color annihilation graphs.
// * Setting of the measured mass for the Higgs.
//
// The user may initialise the generator with all the default Pythia
// parameters and obtain full user control to modify the settings by means
// of invoking the SetUserControl memberfunction before this initialisation.
// Note that the inclusion of elastic and diffractive processes is controlled
// by invokation of the SetElastic() memberfunction before this initialisation,
// irrespective of the UserControl selection. The same is true for the disabling
// of multiple interactions via the memberfunction SetMultiple().

Definition at line 786 of file NcCollider.cxx.

◆ IsSelected()

Int_t NcCollider::IsSelected ( )
protected
// Check whether the generated (sub)event contains one of the particles
// specified in the selection list via SelectEvent().
// If this is the case or when no selection list is present, the value 1
// will be returned, indicating the event is selected to be kept.
// Otherwise the value 0 will be returned.
//
// Note : In case no event was generated (due to possible kinematical constraints),
// also a value 0 will be returned.

Definition at line 2261 of file NcCollider.cxx.

◆ MakeEvent()

Int_t NcCollider::MakeEvent ( Int_t npt = 0,
Int_t mlist = -1,
Int_t medit = 1 )
// Generate one event.
// In case of a nucleus-nucleus interaction, the argument 'npt' denotes
// the total number of participant nucleons.
// So, the range of 'npt' is given by [2,(Abeam+Atarget)].
// Normally also the spectator tracks will be stored into the event structure.
// The spectator tracks have a negative user Id to distinguish them from the
// ordinary generated tracks.
// In case the user has selected the creation of vertex structures, the spectator
// tracks will be linked to the primary vertex.
// However, specification of npt<0 will suppress the storage of spectator tracks.
// In the latter case abs(npt) will be taken as the number of participants.
// In case of a standard Pythia run for 'elementary' particle interactions,
// the value of npt is totally irrelevant.
//
// The argument 'mlist' denotes the list mode used for Pylist().
// Note : mlist<0 suppresses the invokation of Pylist().
// By default, no listing is produced (i.e. mlist=-1).
//
// The argument 'medit' denotes the edit mode used for Pyedit().
// Note : medit<0 suppresses the invokation of Pyedit().
// By default, only 'stable' final particles are kept (i.e. medit=1).
//
// In the case of a standard Pythia run concerning 'elementary' particle
// interactions, the projectile and target particle ID's for the created
// event structure are set to the corresponding Pythia KF codes.
// All the A and Z values are in that case set to zero.
// In case of a nucleus-nucleus interaction, the proper A and Z values for
// the projectile and target particles are set in the event structure.
// However, in this case both particle ID's are set to zero.
//
// Note : Only in case an event passed the selection criteria as specified
// via SelectEvent(), the event will appear on the output file.
//
// The return argument will indicate that an event has been generated (1) or not (0)
// or that an error occurred (-1).

Definition at line 1384 of file NcCollider.cxx.

◆ ProcessJet()

void NcCollider::ProcessJet ( Double_t np,
Double_t gfrac,
TString flux,
Double_t dthmax = 0,
Int_t nlist = 1,
Int_t ntrymax = 1000,
Int_t wxsec = 0,
Double_t finit = 0,
Int_t full = 0 )
// Processing of a Jet simulation for an (obscured) astrophysical source.
// Both the p+p interactions of the jet with the surrounding dust and
// the p+gamma interactions with the ambient photon field are simulated.
//
// The number of events, specification of the produced particles and some
// essential Pythia initialisation parameters are specified via the input arguments
// as outlined below.
//
// Before invokation of this ProcessJet() member function, the user must
// have invoked the member functions SetJetProtonSpectrum() and SetJetGammaSpectrum()
// in order to have all kinematics properly initialized.
// To obtain the data in the corresponding output file(s) also the member function
// SetOutputFile() has to be invoked prior to this ProcessJet() member function.
// Note : Explicit invokation of EndRun() by the user is not needed, since this is
// automatically performed at the end of this ProcessJet() member function.
//
// Further tailoring of the (physics) processing may be obtained by invoking
// the member functions SetMultiple(), SetElastic() and SetPrintFreq()
// before invokation of this ProcessJet() member function.
//
// The produced particle spectra may be obtained from the output file(s)
// as specified via the member function SetOutputFile().
//
// Note :
// ------
// The produced (stable) secondaries are not processed for further interactions.
// This means for instance that a secondary proton produced by a p+gamma interaction
// will not be used anymore for a later p+p interaction in the surrounding dust.
// As such, the produced particle (e.g. neutrino) fluxes are conservative estimates.
//
// Input arguments :
// -----------------
// np : The number of (beam) protons to be processed.
// gfrac : Fraction of the (beam) protons to be used for p+gamma interactions.
// The remaining protons are used for the p+p (dust) interactions.
// flux : Specification of the produced final particle species.
// This allows reduction of Pythia memory usage by declaring various particles as stable.
// Options for selected particle species are : "nu", "gamma", "neutron"
// or any combination by a comma separated list like e.g. "nu,gamma".
// dthmax : Maximum theta (in degrees) variation for the beam (>0) or target (<0) momentum direction.
// The nominal beam and target momenta are aligned with the Z-axis (i.e. theta=0 and theta=180, respectively).
// For variable theta, the phi angle is always randomized between [0,360] degrees.
// nlist : Produce an event listing for the first "nlist" events of each sample.
// ntrymax : Maximum number of phase-space trials per event.
// wxsec : Flag to apply cross section weighting (1) or not (0).
// Note that for varying beam/target momenta cross section weighting will always be used.
// finit : Factor to increase the beam (>0) or target (<0) momentum for initialisation.
// See the Init() member function for details.
// full : Include also the incoming particles, strings etc. in the event (1) or not (0).
//
// Notes for the plain ROOT Tree output file :
// -------------------------------------------
// 1) All selected final particle species appear in a separate Tree.
// However, the Tree called "Data" contains (links to) all
// the data and as such can be used for combined analyses.
// 2) The p+p interactions have a positive run number, whereas
// the p+gamma interactions have a negative run number.
// The run number is available via the observable "evt.jrun".
// 3) The beam and target momenta are available via the observables
// "evt.BeamP", "evt.BeamTheta", "evt.BeamPhi" and
// "evt.TargetP", "evt.TargetTheta" and evt.TargetPhi".
// 4) The energy spectra can be retrieved via the observables ".p".
// Example : "nu_mu.p" provides the nu_mu energy spectrum etc.
//
// Default values : dthmax=0, nlist=1, ntrymax=1000, wxsec=0, finit=0 and full=0.

Definition at line 2653 of file NcCollider.cxx.

◆ SelectEvent()

void NcCollider::SelectEvent ( Int_t id)
// Add a particle to the event selection list.
// The parameter "id" indicates the Pythia KF particle code, which
// basically is the PDG particle identifier code.
// In case the user has built a selection list via this procedure, only the
// events in which one of the particles specified in the list was generated
// will be kept.
// The investigation of the generated particles takes place when the complete
// event is in memory, including all (shortlived) mother particles and resonances.
// So, the settings of the various particle decay modes have no influence on
// the event selection described here.
//
// If no list has been specified, all events will be accepted.
//
// Note : id=0 will delete the selection list.
//
// Be aware of the fact that severe selection criteria (i.e. selecting only
// rare events) may result in long runtimes before an event sample has been
// obtained.

Definition at line 2185 of file NcCollider.cxx.

◆ SetEcmsMin()

void NcCollider::SetEcmsMin ( Double_t ecms)
// Set the minimal CMS energy (in GeV) for events to get generated.
// Notes :
// -------
// 1) This memberfunction may be invoked at will before the initialisation
// or before the generation of any event.
// 2) By default a minimal CMS energy of 2.7 GeV is required for event generation.
// At lower values the underlying Pythia event generation gets rather slow
// because of the limited available phase-space.

Definition at line 697 of file NcCollider.cxx.

◆ SetElastic()

void NcCollider::SetElastic ( Int_t flag)
// Set the flag w.r.t. inclusion of elastic and diffractive processes.
// By default these processes are not included.
// Flag = 0 : Do not include elastic and diffractive processes
// 1 : Elastic and diffractive processes will be included

Definition at line 647 of file NcCollider.cxx.

◆ SetJetGammaSpectrum()

void NcCollider::SetJetGammaSpectrum ( Double_t pmin,
Double_t pmax = -1,
TF1 * fspec = 0,
TH1 * hspec = 0,
Int_t mode = 0 )
// Set the gamma (target) spectrum of the Jet.
// If pmax<=pmin a mono-energetic gamma target with momentum "pmin" will be used,
// otherwise a dN/dp spectrum will be used as described by the function "fspec"
// or the distribution as contained in the histogram "hspec".
// In case "fspec" or "hspec" are specified, cross section weighting will be switched on automatically.
//
// Input arguments :
// -----------------
// pmin : The minimal momentum in GeV/c
// pmax : The maximal momentum in GeV/c
// fspec : (optional) 1D function to describe dN/dp
// hspec : (optional) 1D histogram to describe the momentum distribution (see below)
// mode : 0 --> X-axis of "fspec" or "hspec" is in linear scale
// mode : 1 --> X-axis of "fspec" or "hspec" is in Log10 scale
// mode : 2 --> X-axis of "fspec" or "hspec" is in Ln scale
//
// Note :
// ------
// When "hspec" is specified and "fspec=0", the contents of "hspec" are interpreted
// as an N vs. p spectrum.
// In case both "hspec" and "fspec" are specified, the contents of "hspec" are interpreted
// as a dN/dp spectrum, weighted by "fspec".
//
// Example : When "hspec" is specified and "fspec" represents the function "pow(x,2)", then the contents of "hspec"
// are interpreted as "p^2*dN/dp".
//
// To provide a plain dN/dp spectrum via the "hspec" histogram, "fspec" should represent a constant function.
//
// The default values are pmax=-1, fspec=0, hspec=0 and mode=0.

Definition at line 2485 of file NcCollider.cxx.

◆ SetJetProtonSpectrum()

void NcCollider::SetJetProtonSpectrum ( Double_t pmin,
Double_t pmax = -1,
TF1 * fspec = 0,
TH1 * hspec = 0,
Int_t mode = 0 )
// Set the proton (beam) spectrum of the Jet.
// If pmax<=pmin a mono-energetic proton beam with momentum "pmin" GeV/c will be used,
// otherwise a dN/dp spectrum will be used as described by the function "fspec"
// or the distribution as contained in the histogram "hspec".
// In case "fspec" or "hspec" are specified, cross section weighting will be switched on automatically.
//
// Input arguments :
// -----------------
// pmin : The minimal momentum in GeV/c
// pmax : The maximal momentum in GeV/c
// fspec : (optional) 1D function to describe dN/dp
// hspec : (optional) 1D histogram to describe the momentum distribution (see below)
// mode : 0 --> X-axis of "fspec" or "hspec" is in linear scale
// mode : 1 --> X-axis of "fspec" or "hspec" is in Log10 scale
// mode : 2 --> X-axis of "fspec" or "hspec" is in Ln scale
//
// Note :
// ------
// When "hspec" is specified and "fspec=0", the contents of "hspec" are interpreted
// as an N vs. p spectrum.
// In case both "hspec" and "fspec" are specified, the contents of "hspec" are interpreted
// as a dN/dp spectrum, weighted by "fspec".
//
// Example : When "hspec" is specified and "fspec" represents the function "pow(x,2)", then the contents of "hspec"
// are interpreted as "p^2*dN/dp".
//
// To provide a plain dN/dp spectrum via the "hspec" histogram, "fspec" should represent a constant function.
//
// The default values are pmax=-1, fspec=0, hspec=0 and mode=0.

Definition at line 2357 of file NcCollider.cxx.

◆ SetMomentum()

void NcCollider::SetMomentum ( Nc3Vector & p,
Int_t mode )
// Set c.q. modify the beam or target particle 3-momentum in the case frame="free".
// Invokation of this function only has effect after the initialisation via Init().
//
// Input argument :
// ----------------
// p : Momentum 3-vector in GeV/c
// mode : 1 ==> Modify the beam particle 3-momentum
// 2 ==> Modify the target particle 3-momentum

Definition at line 1339 of file NcCollider.cxx.

◆ SetMultiple()

void NcCollider::SetMultiple ( Int_t flag)
// Set the flag w.r.t. inclusion of multiple interactions.
// By default these processes are included.
// Flag = 0 : Do not include multiple interactions
// 1 : Multiple interactions will be included

Definition at line 672 of file NcCollider.cxx.

◆ SetOutputFile()

NcTreeMaker * NcCollider::SetOutputFile ( TString fname,
Int_t mode = 0 )
// Create the output file containing all the NcEvent structures in a ROOT Tree (mode=0)
// or the output file containing the corresponding NcTreeMaker data (mode=1),
// or create both output files (mode=2).
//
// In the case of mode>0, the return argument provides a pointer to the NcTreeMaker
// object, such that the user may tailor the data to be stored before starting the event generation.
// See the docs of NcTreeMaker for further details.
//
// Environment variables may be used as $(...) in the filenname for convenience.
// For example "$(HOME)/my-data/sample.ncfspack" for full NcEvent data
// or "$(HOME)/my-data/tracks.root" for the corresponding NcTreeMaker data.
//
// Note:
// -----
// For mode=0 and mode=1, the provided filename "name" should contain the file extension,
// like for instance ".ncfspack" or ".root" in the example above.
// However, for mode=2 the filename "name" should NOT contain the file extension,
// since the file extensions ".ncfspack" and ".root" will be generated automatically
// for the correpsonding output file.
//
// The default value is mode=0 for backward compatibility.

Definition at line 360 of file NcCollider.cxx.

◆ SetPrintFreq()

void NcCollider::SetPrintFreq ( Int_t n)
// Set the print frequency for every "n" events.
// By default the printfrequency is set to 1 (i.e. every event).
// When n=0 no printout will be performed.

Definition at line 595 of file NcCollider.cxx.

◆ SetRandomSeed()

void NcCollider::SetRandomSeed ( Int_t iseed)
// Initialise the random number generator with a specific sequence.
// Regular allowed values are 0<=iseed<=900000000.
// However, also the specification iseed<0 is allowed to obtain an
// automatic sequence selection as explained below.
//
// Notes :
// -------
// 1) In case the user does not invoke this memberfunction, the default
// Pythia seed will be used.
// 2) This memberfunction may be invoked at will before the initialisation
// or before the generation of any event.
// 3) A convenient way to automatically start each NcCollider run with a
// different seed is to construct the seed from e.g. the date and time.
// An automatic (quasi unique) seed generation based on date and time information
// (with second precision) is obtained by providing iseed<0 as input argument.

Definition at line 726 of file NcCollider.cxx.

◆ SetResolution()

void NcCollider::SetResolution ( Double_t res)
// Set the resolution (in meter) for resolving (sec.) vertices.
// By default this resolution is set to 0.1 micron.
// Note : In case no vertex creation has been selected, the value of
// the resolution is totally irrelevant.

Definition at line 547 of file NcCollider.cxx.

◆ SetRunNumber()

void NcCollider::SetRunNumber ( Int_t run)
// Set the user defined run number.
// By default the run number is set to 0.

Definition at line 572 of file NcCollider.cxx.

◆ SetSpectatorPmin()

void NcCollider::SetSpectatorPmin ( Float_t pmin)
// Set minimal momentum in GeV/c for spectator tracks to be stored.
// Spectator tracks with a momentum below this threshold will not be stored
// in the (output) event structure.
// This facility allows to minimise the output file size.
// Note that when the user wants to boost the event into another reference
// frame these spectator tracks might have got momenta above the threshold.
// However, when the spectator tracks were not stored in the event structure
// in the original frame, there is no way to retreive them anymore.

Definition at line 2302 of file NcCollider.cxx.

◆ SetStable()

void NcCollider::SetStable ( Int_t id,
Int_t mode = 1,
Int_t cls = 0 )
// Declare whether a particle (class) must be regarded as stable or not.
//
// Input arguments :
// -----------------
// id = The Pythia KF particle code, which basically is the PDG particle identifier code.
// = 0 ==> Will invoke the setting for a whole particle class (see below).
// mode = 1 : The specified particle (class) will be regarded as stable.
// 0 : The specified particle (class) will be able to decay.
// cls = 1 : Quarks
// 2 : Leptons
// 3 : Gauge Bosons (including photons and the Higgs)
// 4 : Mesons
// 5 : Baryons
//
// In case the user does NOT explicitly invoke this function, the standard
// Pythia settings for the decay tables are used.
//
// Default values are mode=1 and cls=0.
//
// Notes :
// -------
// 1) This function should be invoked after the initialisation call
// to NcCollider::Init.
// 2) Due to the internals of Pythia, there is no need to specify particles
// and their corresponding anti-particles separately as (un)stable.
// Once a particle has been declared (un)stable, the corresponding
// anti-particle will be treated in the same way.
// 3) After declaring a whole particle class stable/unstable, specific particles
// can be (re)declared unstable/stable by invoking this function again
// for the specific particle(s).

Definition at line 2077 of file NcCollider.cxx.

◆ SetUserControl()

void NcCollider::SetUserControl ( Int_t flag)
// Set the user control flag w.r.t. disabling automatic optimisation
// of some Pythia default MC parameters for soft interactions in view of
// nucleus-nucleus collisions and astrophysical processes.
// Flag = 0 : Limited user control (automatic optimisation enabled)
// 1 : Full user control (automatic optimisation disabled)
// By default the user control is set to 0 (i.e. automatic optimisation).
// See the Init() memberfunctions for further details w.r.t. the optimisations.

Definition at line 619 of file NcCollider.cxx.

◆ SetVertexMode()

void NcCollider::SetVertexMode ( Int_t mode)
// Set the mode of the vertex structure creation.
//
// By default all generated tracks will only appear in the NcEvent
// structure without any primary (and secondary) vertex structure.
// The user can build the vertex structure if he/she wants by means
// of the beginpoint location of each NcTrack.
//
// However, one can also let NcCollider automatically create
// the primary (and secondary) vertex structure(s).
// In this case the primary vertex is given Id=1 and all sec. vertices
// are given Id's 2,3,4,....
// All vertices are created as standalone entities in the NcEvent structure
// without any linking between the various vertices.
// For this automated process, the user-selected resolution
// (see SetResolution) is used to decide whether or not certain vertex
// locations can be resolved.
// In case no vertex creation is selected (i.e. the default mode=0),
// the value of the resolution is totally irrelevant.
//
// The user can also let NcCollider automatically connect the sec. vertices
// to the primary vertex (i.e. mode=3). This process will also automatically
// generate the tracks connecting the vertices.
// Note that the result of the mode=3 operation may be very sensitive to
// the resolution parameter. Therefore, no attempt is made to distinguish
// between secondary, tertiary etc... vertices. All sec. vertices are
// linked to the primary one.
//
// Irrespective of the selected mode, all generated tracks can be obtained
// directly from the NcEvent structure.
// In case (sec.) vertex creation is selected, all generated vertices can
// also be obtained directly from the NcEvent structure.
// These (sec.) vertices contain only the corresponding pointers to the various
// tracks which are stored in the NcEvent structure.
//
// Overview of vertex creation modes :
// -----------------------------------
// mode = 0 ==> No vertex structure will be created
// 1 ==> Only primary vertex structure will be created
// 2 ==> Unconnected primary and secondary vertices will be created
// 3 ==> Primary and secondary vertices will be created where all the
// sec. vertices will be connected to the primary vertex.
// Also the vertex connecting tracks will be automatically
// generated.

Definition at line 475 of file NcCollider.cxx.

Member Data Documentation

◆ fAproj

Int_t NcCollider::fAproj
protected

Definition at line 76 of file NcCollider.h.

◆ fAtarg

Int_t NcCollider::fAtarg
protected

Definition at line 78 of file NcCollider.h.

◆ fBeam

NcTrack NcCollider::fBeam
protected

Definition at line 72 of file NcCollider.h.

◆ fEcmsmin

Double_t NcCollider::fEcmsmin
protected

Definition at line 89 of file NcCollider.h.

◆ fElastic

Int_t NcCollider::fElastic
protected

Definition at line 87 of file NcCollider.h.

◆ fEvent

NcEvent* NcCollider::fEvent
protected

Definition at line 84 of file NcCollider.h.

◆ fEventnum

Int_t NcCollider::fEventnum
protected

Definition at line 68 of file NcCollider.h.

◆ fEvtuser

NcSignal NcCollider::fEvtuser
protected

Definition at line 101 of file NcCollider.h.

◆ fFracnn

Float_t NcCollider::fFracnn
protected

Definition at line 82 of file NcCollider.h.

◆ fFracnp

Float_t NcCollider::fFracnp
protected

Definition at line 80 of file NcCollider.h.

◆ fFracpn

Float_t NcCollider::fFracpn
protected

Definition at line 81 of file NcCollider.h.

◆ fFracpp

Float_t NcCollider::fFracpp
protected

Definition at line 79 of file NcCollider.h.

◆ fFrame

TString NcCollider::fFrame
protected

Definition at line 70 of file NcCollider.h.

◆ fJetGpmax

Double_t NcCollider::fJetGpmax
protected

Definition at line 107 of file NcCollider.h.

◆ fJetGpmin

Double_t NcCollider::fJetGpmin
protected

Definition at line 106 of file NcCollider.h.

◆ fJetGscale

Int_t NcCollider::fJetGscale
protected

Definition at line 111 of file NcCollider.h.

◆ fJetGspectrum

TH1* NcCollider::fJetGspectrum
protected

Definition at line 110 of file NcCollider.h.

◆ fJetPpmax

Double_t NcCollider::fJetPpmax
protected

Definition at line 105 of file NcCollider.h.

◆ fJetPpmin

Double_t NcCollider::fJetPpmin
protected

Definition at line 104 of file NcCollider.h.

◆ fJetPscale

Int_t NcCollider::fJetPscale
protected

Definition at line 109 of file NcCollider.h.

◆ fJetPspectrum

TH1* NcCollider::fJetPspectrum
protected

Definition at line 108 of file NcCollider.h.

◆ fJob

NcJob* NcCollider::fJob
protected

Definition at line 100 of file NcCollider.h.

◆ fLab

NcAstrolab NcCollider::fLab
protected

Definition at line 112 of file NcCollider.h.

◆ fLorbo

NcBoost NcCollider::fLorbo
protected

Definition at line 91 of file NcCollider.h.

◆ fMktree

NcTreeMaker* NcCollider::fMktree
protected

Definition at line 99 of file NcCollider.h.

◆ fMultiple

Int_t NcCollider::fMultiple
protected

Definition at line 88 of file NcCollider.h.

◆ fNucl

Int_t NcCollider::fNucl
protected

Definition at line 74 of file NcCollider.h.

◆ fOutFile

TFile* NcCollider::fOutFile
protected

Definition at line 93 of file NcCollider.h.

◆ fOutTree

TTree* NcCollider::fOutTree
protected

Definition at line 94 of file NcCollider.h.

◆ fPrintfreq

Int_t NcCollider::fPrintfreq
protected

Definition at line 69 of file NcCollider.h.

◆ fRan

NcRandom NcCollider::fRan
protected

Definition at line 83 of file NcCollider.h.

◆ fResolution

Double_t NcCollider::fResolution
protected

Definition at line 66 of file NcCollider.h.

◆ fRunnum

Int_t NcCollider::fRunnum
protected

Definition at line 67 of file NcCollider.h.

◆ fSelect

Int_t NcCollider::fSelect
protected

Definition at line 97 of file NcCollider.h.

◆ fSelections

TArrayI* NcCollider::fSelections
protected

Definition at line 96 of file NcCollider.h.

◆ fSpecpmin

Float_t NcCollider::fSpecpmin
protected

Definition at line 85 of file NcCollider.h.

◆ fTarget

NcTrack NcCollider::fTarget
protected

Definition at line 73 of file NcCollider.h.

◆ fUserctrl

Int_t NcCollider::fUserctrl
protected

Definition at line 86 of file NcCollider.h.

◆ fVertexmode

Int_t NcCollider::fVertexmode
protected

Definition at line 65 of file NcCollider.h.

◆ fWin

Float_t NcCollider::fWin
protected

Definition at line 71 of file NcCollider.h.

◆ fWxsec

Int_t NcCollider::fWxsec
protected

Definition at line 90 of file NcCollider.h.

◆ fZproj

Int_t NcCollider::fZproj
protected

Definition at line 75 of file NcCollider.h.

◆ fZtarg

Int_t NcCollider::fZtarg
protected

Definition at line 77 of file NcCollider.h.

The documentation for this class was generated from the following files: