[u/mrichter/AliRoot.git] / TEvtGen / Photos / Photos.h

#ifndef _Photos_h_included_
#define _Photos_h_included_

/**
 * @class Photos
 *
 * @brief Controls the configuration and initialization of Photos.
 *
 * This is the main configuration class for Photos C++ Interface.
 * It is also used for invoking methods for processing single particle or branch.
 *
 * @author Nadia Davidson
 * @date 16th June 2008
 *
 */
#include <stdarg.h>
#include <vector>
#include "PhotosParticle.h"
#include "PhotosRandom.h"
#include "f_Init.h"
// WARNING: VARIANT B of phase space generation was not tested in C++ for all
// options of the program initialization.. 
//#define VARIANTB true
using std::vector;
using std::pair;

namespace Photospp
{

class PhotosParticle;

class Photos
{
public:
	static const int VER_MAJOR=3, VER_MINOR=54;
	static const int DAT_DAY  =2, DAT_MONTH=12,DAT_YEAR=13;
public:

	/** Initalize Photos with the parameters previously set via the
	   setter methods */
	static void initialize();

	/** Prints info on  Photos initialization (reinitialization)
	   status */
	static void iniInfo();

	/** Process decay of single particle */
	static void processParticle(PhotosParticle *p);
	/** Process decay of whole decay branch starting from given particle */
	static void processBranch(PhotosParticle *p);

	/** Suppress processing of a single decay */
	static void suppressBremForDecay (int count, int motherID, ... );
	/** Suppress processing of whole decay branch */
	static void suppressBremForBranch(int count, int motherID, ... );

	/** Suppress all processing. Only forced decays will be processed. */
	static void suppressAll()                      { isSuppressed=true; }

	/** Force processing of a single decay */
	static void forceBremForDecay (int count, int motherID, ... );

	/** Force processing of a whole decay branch */
	static void forceBremForBranch(int count, int motherID, ... );

  /** Block emissions id decays pi0 and K_L -> gamma e+ e- 
      1           = no suppression
      2 (default) = suppressed emissions in K_L -> gamma e+ e- ... and all pi0 decays */
  static void IPHEKL_setPi0KLnoEmission(int m);

  static bool IPHQRK_setQarknoEmission(int MODCOR, int PDGID);
  
  /** If event record allows it, create history entries of particles
      before Photos processing */
  static void createHistoryEntries(bool flag, int status);

  /** Ignore particles with given status code */
  static void ignoreParticlesOfStatus(int status);

  /** Remove 'status' from the list of ignored status codes */
  static void deIgnoreParticlesOfStatus(int status);
  
  /** Returns 'true' if status code is ignored */
  static bool isStatusCodeIgnored(int status);
public:
  /** Substitute build-in generator with external one */
  static void setRandomGenerator( double (*gen)() );

	/** Seed for RANMAR used by fortran part of the Photos */
	static void setSeed(int iseed1, int iseed2)    { PhotosRandom::setSeed(iseed1,iseed2); }

	/** Maximum interference weight */
	static void maxWtInterference(double interference) { phokey_.fint=interference; }

	/** Minimal energy (in units of decaying particle mass) for photons to be explicitly generated */
	static void setInfraredCutOff(double cut_off)  { phocop_.xphcut=cut_off; }

	/** Coupling constant alpha QED */
	static void setAlphaQED(double alpha)          { phocop_.alpha=alpha; }

	/** Key for interference, matrix element weight */
	static void setInterference(bool interference) { phokey_.interf=(int)interference; }

	/** Set double bremsstrahlung generation */
	static void setDoubleBrem(bool doub)           { phokey_.isec=(int)doub; }

	/** Set bremsstrahlung generation up to multiplicity of 4 */
	static void setQuatroBrem(bool quatroBrem)     { phokey_.itre=(int)quatroBrem; }

	/* Key for partial effects of  matrix element (in leptonic W decays) */
	static void setCorrectionWtForW(bool corr) { phokey_.ifw=(int)corr; }

	/** Set exponentiation mode */
	static void setExponentiation(bool expo);

	/** Switch for complete effects of matrix element (in  scalar  to 2 scalars decays) */
	static void setMeCorrectionWtForScalar(bool corr);

	/** Switch for complete effects of matrix element (in leptonic W decays) */
	static void setMeCorrectionWtForW(bool corr);

	/** Switch for complete effects of matrix element (in leptonic Z decays) */
	static void setMeCorrectionWtForZ(bool corr);

	/** Set photon emission in top pair production in quark (gluon) pair annihilation */
	static void setTopProcessRadiation(bool top)         { phokey_.iftop=(int)top; }

	/* Set if PHOTOS should stop at critical error. True by default.
	   WARNING: These stops are an essential source of debugging information flow
                    from event record to PHOTOS algorithm. Never switch it off! The only exception:
	            you have checked your set-up including particular physics initialization
                    with the substantially large sample and you submit large production. */
	static void setStopAtCriticalError(bool stop);

	/** Initialize kinematic corrections */
	static void initializeKinematicCorrections(int flag) { PHCORK(flag); }

	/** Force mass value to be sqrt(e^2-p^2) for all particle momenta
	    taken from event record. May be important for numerical stability.
		May lead to faulty results due to rounding errors for
		hiper-relativistic electron, for example. */
	static void forceMassFrom4Vector(bool flag) { massFrom4Vector=flag; }
	
  /** When particles with PDGID and -PDGID will be processed by Photos,
      their mass value will be taken from event record instead of being
      calculated from 4-vector.

      This works only if 'forceMassFrom4Vector' is set to 'true' (default)      
      This routine may be executed several times with different PDGID values. */
  static void forceMassFromEventRecord(int pdgid);

  /** When particles with PDGID and -PDGID will be processed by Photos,
      their mass value will be given by user instead of being calculated
      from 4-vector.

      This works only if 'forceMassFrom4Vector' is set to 'true' (default)
      This routine may be executed several times with different PDGID values. */  
  static void forceMass(int pdgid, double mass);

	/** set energy momentum conservation threshold */
	static void setMomentumConservationThreshold(double threshold){momentum_conservation_threshold=threshold; }

public:
	/** Is in suppressed mode */
	static bool isSuppressed;

	/** Is mass from 4-vector or from event record */
	static bool massFrom4Vector;
	
	/** List of suppressed decays */
	static vector<vector<int>* >    *supBremList;

	/** List of forced decays */
	static vector<vector<int>* >    *forceBremList;

	/** List of forced mass values */
	static vector<pair<int,double>* > *forceMassList;
  
  /** List of ignored status codes */
	static vector<int >             *ignoreStatusCodeList;

 	/** Threshold for momentum conservation check */
	static double momentum_conservation_threshold;

	/** Flag for complete effects of matrix element (in scalars decays) */
	static bool meCorrectionWtForScalar;

	/** Flag for complete effects of matrix element (in leptonic Z decays) */
	static bool meCorrectionWtForZ;
	
	/** Flag for complete effects of matrix element (in leptonic W decays) */
	static bool meCorrectionWtForW;
  
  /** Flag for creating historic entries */
  static bool isCreateHistoryEntries;

  /** Status of history entries */
  static int  historyEntriesStatus;

  /** Pointer to random generator function */
  static double (*randomDouble)();
public:
	/** Get instance of Photos */
	Photos& getInstance() { return _instance; }
private:
	/* Singleton: only one instance allowed.
	   Constructor sets default values of PHOTOS parameters */
	 Photos();
	~Photos() {}
	Photos(const Photos&);
	Photos& operator=(const Photos&);
	static Photos _instance;
};

} // namespace Photospp
#endif
Commit	Line	Data
0ca57c2f	1	#ifndef _Photos_h_included_
	2	#define _Photos_h_included_
	3
	4	/**
	5	* @class Photos
	6	*
	7	* @brief Controls the configuration and initialization of Photos.
	8	*
	9	* This is the main configuration class for Photos C++ Interface.
	10	* It is also used for invoking methods for processing single particle or branch.
	11	*
	12	* @author Nadia Davidson
	13	* @date 16th June 2008
	14	*
	15	*/
	16	#include <stdarg.h>
	17	#include <vector>
	18	#include "PhotosParticle.h"
	19	#include "PhotosRandom.h"
	20	#include "f_Init.h"
	21	// WARNING: VARIANT B of phase space generation was not tested in C++ for all
	22	// options of the program initialization..
	23	//#define VARIANTB true
	24	using std::vector;
	25	using std::pair;
	26
	27	namespace Photospp
	28	{
	29
	30	class PhotosParticle;
	31
	32	class Photos
	33	{
	34	public:
	35	static const int VER_MAJOR=3, VER_MINOR=54;
	36	static const int DAT_DAY =2, DAT_MONTH=12,DAT_YEAR=13;
	37	public:
	38
	39	/** Initalize Photos with the parameters previously set via the
	40	setter methods */
	41	static void initialize();
	42
	43	/** Prints info on Photos initialization (reinitialization)
	44	status */
	45	static void iniInfo();
	46
	47	/** Process decay of single particle */
	48	static void processParticle(PhotosParticle *p);
	49	/** Process decay of whole decay branch starting from given particle */
	50	static void processBranch(PhotosParticle *p);
	51
	52	/** Suppress processing of a single decay */
	53	static void suppressBremForDecay (int count, int motherID, ... );
	54	/** Suppress processing of whole decay branch */
	55	static void suppressBremForBranch(int count, int motherID, ... );
	56
	57	/** Suppress all processing. Only forced decays will be processed. */
	58	static void suppressAll() { isSuppressed=true; }
	59
	60	/** Force processing of a single decay */
	61	static void forceBremForDecay (int count, int motherID, ... );
	62
	63	/** Force processing of a whole decay branch */
	64	static void forceBremForBranch(int count, int motherID, ... );
65
66	/** Block emissions id decays pi0 and K_L -> gamma e+ e-
67	1 = no suppression
68	2 (default) = suppressed emissions in K_L -> gamma e+ e- ... and all pi0 decays */
69	static void IPHEKL_setPi0KLnoEmission(int m);
70
71	static bool IPHQRK_setQarknoEmission(int MODCOR, int PDGID);
72
73	/** If event record allows it, create history entries of particles
74	before Photos processing */
75	static void createHistoryEntries(bool flag, int status);
76
77	/** Ignore particles with given status code */
78	static void ignoreParticlesOfStatus(int status);
79
80	/** Remove 'status' from the list of ignored status codes */
81	static void deIgnoreParticlesOfStatus(int status);
82
83	/** Returns 'true' if status code is ignored */
84	static bool isStatusCodeIgnored(int status);
85	public:
86	/** Substitute build-in generator with external one */
87	static void setRandomGenerator( double (*gen)() );
88
89	/** Seed for RANMAR used by fortran part of the Photos */
90	static void setSeed(int iseed1, int iseed2) { PhotosRandom::setSeed(iseed1,iseed2); }
91
92	/** Maximum interference weight */
93	static void maxWtInterference(double interference) { phokey_.fint=interference; }
94
95	/** Minimal energy (in units of decaying particle mass) for photons to be explicitly generated */
96	static void setInfraredCutOff(double cut_off) { phocop_.xphcut=cut_off; }
97
98	/** Coupling constant alpha QED */
99	static void setAlphaQED(double alpha) { phocop_.alpha=alpha; }
100
101	/** Key for interference, matrix element weight */
102	static void setInterference(bool interference) { phokey_.interf=(int)interference; }
103
104	/** Set double bremsstrahlung generation */
105	static void setDoubleBrem(bool doub) { phokey_.isec=(int)doub; }
106
107	/** Set bremsstrahlung generation up to multiplicity of 4 */
108	static void setQuatroBrem(bool quatroBrem) { phokey_.itre=(int)quatroBrem; }
109
110	/* Key for partial effects of matrix element (in leptonic W decays) */
111	static void setCorrectionWtForW(bool corr) { phokey_.ifw=(int)corr; }
112
113	/** Set exponentiation mode */
114	static void setExponentiation(bool expo);
115
116	/** Switch for complete effects of matrix element (in scalar to 2 scalars decays) */
117	static void setMeCorrectionWtForScalar(bool corr);
118
119	/** Switch for complete effects of matrix element (in leptonic W decays) */
120	static void setMeCorrectionWtForW(bool corr);
121
122	/** Switch for complete effects of matrix element (in leptonic Z decays) */
123	static void setMeCorrectionWtForZ(bool corr);
124
125	/** Set photon emission in top pair production in quark (gluon) pair annihilation */
126	static void setTopProcessRadiation(bool top) { phokey_.iftop=(int)top; }
127
128	/* Set if PHOTOS should stop at critical error. True by default.
129	WARNING: These stops are an essential source of debugging information flow
130	from event record to PHOTOS algorithm. Never switch it off! The only exception:
131	you have checked your set-up including particular physics initialization
132	with the substantially large sample and you submit large production. */
133	static void setStopAtCriticalError(bool stop);
134
135	/** Initialize kinematic corrections */
136	static void initializeKinematicCorrections(int flag) { PHCORK(flag); }
137
138	/** Force mass value to be sqrt(e^2-p^2) for all particle momenta
139	taken from event record. May be important for numerical stability.
140	May lead to faulty results due to rounding errors for
141	hiper-relativistic electron, for example. */
142	static void forceMassFrom4Vector(bool flag) { massFrom4Vector=flag; }
143
144	/** When particles with PDGID and -PDGID will be processed by Photos,
145	their mass value will be taken from event record instead of being
146	calculated from 4-vector.
147
148	This works only if 'forceMassFrom4Vector' is set to 'true' (default)
149	This routine may be executed several times with different PDGID values. */
150	static void forceMassFromEventRecord(int pdgid);
151
152	/** When particles with PDGID and -PDGID will be processed by Photos,
153	their mass value will be given by user instead of being calculated
154	from 4-vector.
155
156	This works only if 'forceMassFrom4Vector' is set to 'true' (default)
157	This routine may be executed several times with different PDGID values. */
158	static void forceMass(int pdgid, double mass);
159
160	/** set energy momentum conservation threshold */
161	static void setMomentumConservationThreshold(double threshold){momentum_conservation_threshold=threshold; }
162
163	public:
164	/** Is in suppressed mode */
165	static bool isSuppressed;
166
167	/** Is mass from 4-vector or from event record */
168	static bool massFrom4Vector;
169
170	/** List of suppressed decays */
171	static vector<vector<int>* > *supBremList;
172
173	/** List of forced decays */
174	static vector<vector<int>* > *forceBremList;
175
176	/** List of forced mass values */
177	static vector<pair<int,double>* > *forceMassList;
178
179	/** List of ignored status codes */
180	static vector<int > *ignoreStatusCodeList;
181
182	/** Threshold for momentum conservation check */
183	static double momentum_conservation_threshold;
184
185	/** Flag for complete effects of matrix element (in scalars decays) */
186	static bool meCorrectionWtForScalar;
187
188	/** Flag for complete effects of matrix element (in leptonic Z decays) */
189	static bool meCorrectionWtForZ;
190
191	/** Flag for complete effects of matrix element (in leptonic W decays) */
192	static bool meCorrectionWtForW;
193
194	/** Flag for creating historic entries */
195	static bool isCreateHistoryEntries;
196
197	/** Status of history entries */
198	static int historyEntriesStatus;
199
200	/** Pointer to random generator function */
201	static double (*randomDouble)();
202	public:
203	/** Get instance of Photos */
204	Photos& getInstance() { return _instance; }
205	private:
206	/* Singleton: only one instance allowed.
207	Constructor sets default values of PHOTOS parameters */
208	Photos();
209	~Photos() {}
210	Photos(const Photos&);
211	Photos& operator=(const Photos&);
212	static Photos _instance;
213	};
214
215	} // namespace Photospp
216	#endif
217