]>
Commit | Line | Data |
---|---|---|
7dae8538 | 1 | #ifndef ROOT_TIsajet |
2 | #define ROOT_TIsajet | |
3 | ||
4 | /**************************************************************************/ | |
5 | /* */ | |
6 | /* TIsajet */ | |
7 | /* */ | |
8 | /* This class implements an interface to the Isajet event generator. */ | |
9 | /* */ | |
10 | /**************************************************************************/ | |
11 | ||
12 | #ifndef ROOT_TGenerator | |
13 | #include "TGenerator.h" | |
14 | #include "AliRndm.h" | |
15 | #endif | |
16 | ||
17 | class TIsajet : public TGenerator , public AliRndm | |
18 | { | |
19 | // | |
20 | private: | |
21 | ||
22 | Char_t *title, *jobtype; | |
23 | Char_t* pdfpar[20]; | |
24 | Float_t pdfval[20]; | |
25 | Int_t num_Pdf; | |
26 | Int_t beam1_type, beam2_type; | |
27 | Float_t cutoff_mass; | |
28 | Float_t center_energy; | |
29 | Float_t frag_params[32]; | |
30 | Char_t *jet1_type[30], *jet2_type[30], *jet3_type[30]; | |
31 | Int_t num_jet_type[3]; | |
32 | Float_t qcd_lambda; | |
33 | Bool_t forbid_decay, forbid_eta, forbid_evolve, forbid_hadron, forbid_pi0; | |
34 | Int_t generate_sigma; | |
35 | Float_t p_limits[6]; | |
36 | Float_t phi_limits[6]; | |
37 | Float_t pt_limits[6]; | |
38 | Float_t theta_limits[6]; | |
39 | Float_t x_limits[6]; | |
40 | Float_t y_limits[6]; | |
41 | Float_t peter_jet_frag[8]; | |
42 | ||
43 | Bool_t setCutjet, setBeams, setFragment, setJettype1; | |
44 | Bool_t setJettype2, setJettype3, setLambda, setNodcay; | |
45 | Bool_t setNoeta, setNoevolve, setNohadron, setNopi0; | |
46 | Bool_t setNsigma, setP, setPhi, setPt, setTheta; | |
47 | Bool_t setX, setXgen, setY, setPdf, online; | |
48 | ||
49 | public: | |
50 | ||
51 | TIsajet(); | |
52 | // TIsajet(Float_t Energy_CM); | |
53 | virtual ~TIsajet(); | |
54 | ||
55 | virtual void Initialise(); | |
56 | ||
57 | virtual void Reload(); | |
58 | ||
59 | virtual void RestoreDefaults(); | |
60 | ||
61 | virtual Int_t ImportParticles(TClonesArray *particles, Option_t *option = ""); | |
62 | ||
63 | virtual void GenerateEvent(); | |
64 | ||
65 | virtual void SetJobtype(Char_t *val); | |
66 | virtual void GetJobtype() const; | |
67 | ||
68 | virtual void SetOnline(Bool_t val); | |
69 | virtual Bool_t GetOnline() const; | |
70 | ||
71 | virtual void SetPDF(Char_t *name, Float_t val); | |
72 | ||
73 | virtual void Isaini(Int_t& j, Int_t& k, Int_t& m, Int_t& n); | |
74 | ||
75 | virtual void Isaevt(Int_t& j, Int_t& k, Int_t& m); | |
76 | ||
77 | virtual void Openfiles(); | |
78 | ||
ff118c7c | 79 | virtual void PDFinit(Int_t& pdfpar, Int_t& pdfval); |
7dae8538 | 80 | |
81 | virtual void Isabeg(Int_t& ifl); | |
82 | ||
83 | virtual void Isabg2(Int_t& ifl); | |
84 | ||
85 | // Parameters for the event. | |
86 | // Variable explanations in Icommon.h | |
87 | // Common block DYLIM access routines : | |
88 | ||
89 | virtual void SetQMIN(Float_t val); | |
90 | virtual Float_t GetQMIN() const; | |
91 | ||
92 | virtual void SetQMAX(Float_t val); | |
93 | virtual Float_t GetQMAX() const; | |
94 | ||
95 | virtual void SetQTMIN(Float_t val); | |
96 | virtual Float_t GetQTMIN() const; | |
97 | ||
98 | virtual void SetQTMAX(Float_t val); | |
99 | virtual Float_t GetQTMAX() const; | |
100 | ||
101 | virtual void SetYWMIN(Float_t val); | |
102 | virtual Float_t GetYWMIN() const; | |
103 | ||
104 | virtual void SetYWMAX(Float_t val); | |
105 | virtual Float_t GetYWMAX() const; | |
106 | ||
107 | virtual void SetYWLIMS(); | |
108 | ||
109 | // YWMIN and YWMAX default to a function of QMIN, QTMIN; they are recalculated | |
110 | // whenever either value is set, unless they have been fixed by hand (ie using | |
111 | // their setters). | |
112 | ||
113 | virtual void SetXWMIN(Float_t val); | |
114 | virtual Float_t GetXWMIN() const; | |
115 | ||
116 | virtual void SetXWMAX(Float_t val); | |
117 | virtual Float_t GetXWMAX() const; | |
118 | ||
119 | virtual void SetTHWMIN(Float_t val); | |
120 | virtual Float_t GetTHWMIN() const; | |
121 | ||
122 | virtual void SetTHWMAX(Float_t val); | |
123 | virtual Float_t GetTHWMAX() const; | |
124 | ||
125 | virtual void SetTHWLIMS(); | |
126 | ||
127 | virtual void SetPHWMIN(Float_t val); | |
128 | virtual Float_t GetPHWMIN() const; | |
129 | ||
130 | virtual void SetPHWMAX(Float_t val); | |
131 | virtual Float_t GetPHWMAX() const; | |
132 | ||
133 | virtual Bool_t GetSETLMQ(Int_t index) const; | |
134 | ||
135 | // Ends DYLIM | |
136 | // Common block EEPAR access routines | |
137 | ||
138 | virtual void SetPLEP(Float_t val); | |
139 | virtual Float_t GetPLEP() const; | |
140 | ||
141 | virtual void SetPLEM(Float_t val); | |
142 | virtual Float_t GetPLEM() const; | |
143 | ||
144 | virtual void SetRSHMIN(Float_t val); | |
145 | virtual Float_t GetRSHMIN() const; | |
146 | ||
147 | virtual void SetRSHMAX(Float_t val); | |
148 | virtual Float_t GetRSHMAX() const; | |
149 | ||
150 | virtual void SetUPSLON(Float_t val); | |
151 | virtual Float_t GetUPSLON() const; | |
152 | ||
153 | virtual void SetSIGZ(Float_t val); | |
154 | virtual Float_t GetSIGZ() const; | |
155 | ||
156 | virtual Bool_t GetIBREM() const; | |
157 | ||
158 | virtual Bool_t GetIBEAM() const; | |
159 | ||
160 | virtual Float_t GetSGMXEE() const; | |
161 | ||
162 | // Ends EEPAR | |
163 | // Common block FORCE access routines | |
164 | ||
165 | virtual Int_t GetNFORCE() const; | |
166 | ||
167 | virtual void SetIFORCE(const Int_t val[], Int_t arraySize, Bool_t anti = true); | |
168 | virtual void UnForce(Int_t index, Bool_t anti = true); | |
169 | virtual void UnForceID(Int_t particle_ID, Bool_t anti = true); | |
170 | // If anti is false, the antiparticle's decay is not forced / unforced. | |
171 | ||
172 | virtual Int_t* GetIFORCE(Int_t index) const; | |
173 | ||
174 | virtual Int_t GetMEFORC(Int_t index) const; | |
175 | ||
176 | // Ends FORCE | |
177 | // Common block FRGPAR access routines | |
178 | ||
179 | virtual void SetFRPAR(Float_t val, Int_t index); | |
180 | virtual void SetAllFRPAR(const Float_t val[], Int_t arraySize); | |
181 | virtual Float_t GetFRPAR(Int_t index) const; | |
182 | ||
183 | virtual void SetPUD(Float_t val); | |
184 | virtual Float_t GetPUD() const; | |
185 | ||
186 | virtual void SetPBARY(Float_t val); | |
187 | virtual Float_t GetPBARY() const; | |
188 | ||
189 | virtual void SetSIGQT(Float_t val); | |
190 | virtual Float_t GetSIGQT() const; | |
191 | ||
192 | virtual void SetPEND(Float_t val); | |
193 | virtual Float_t GetPEND() const; | |
194 | ||
195 | virtual void SetXGEN(Float_t val, Int_t index); | |
196 | virtual void SetAllXGEN(const Float_t val[], Int_t arraySize); | |
197 | virtual Float_t GetXGEN(Int_t index) const; | |
198 | ||
199 | virtual void SetPSPIN1(Float_t val, Int_t index); | |
200 | virtual void SetAllPSPIN1(const Float_t val[], Int_t arraySize); | |
201 | virtual Float_t GetPSPIN1(Int_t index) const; | |
202 | ||
203 | virtual void SetPMIX1(Float_t val, Int_t index1, Int_t index2); | |
204 | virtual void SetAllPMIX1(const Float_t val[2][3]); | |
205 | virtual void SetColumnPMIX1(const Float_t val[], Int_t col); | |
206 | virtual Float_t GetPMIX1(Int_t index1, Int_t index2) const; | |
207 | ||
208 | virtual void SetPMIX2(Float_t val, Int_t index1, Int_t index2); | |
209 | virtual void SetAllPMIX2(const Float_t val[2][3]); | |
210 | virtual void SetColumnPMIX2(const Float_t val[], Int_t col); | |
211 | virtual Float_t GetPMIX2(Int_t index1, Int_t index2) const; | |
212 | ||
213 | virtual void SetPMIXX1(Float_t val, Int_t index); | |
214 | virtual void SetAllPMIXX1(const Float_t val[], Int_t arraySize); | |
215 | virtual Float_t GetPMIXX1(Int_t index) const; | |
216 | ||
217 | virtual void SetPMIXX2(Float_t val, Int_t index); | |
218 | virtual void SetAllPMIXX2(const Float_t val[], Int_t arraySize); | |
219 | virtual Float_t GetPMIXX2(Int_t index) const; | |
220 | ||
221 | virtual void SetXGENSS(Float_t val, Int_t index); | |
222 | virtual void SetAllXGENSS(const Float_t val[], Int_t arraySize); | |
223 | virtual Float_t GetXGENSS(Int_t index) const; | |
224 | ||
225 | // Ends FRGPAR | |
226 | // Common block HCON access routines | |
227 | ||
228 | virtual Float_t GetANWWWW(Int_t index1, Int_t index2, Int_t index3) const; | |
229 | ||
230 | virtual Float_t GetADWWWW(Int_t index1, Int_t index2) const; | |
231 | ||
232 | virtual Float_t GetAIWWWW(Int_t index) const; | |
233 | ||
234 | virtual Float_t GetHMASS() const; | |
235 | ||
236 | virtual Float_t GetHGAM() const; | |
237 | ||
238 | virtual Float_t GetHGAMS(Int_t index) const; | |
239 | ||
240 | virtual Float_t GetETAHGG() const; | |
241 | ||
242 | virtual Int_t GetMATCHH(Int_t index) const; | |
243 | ||
244 | virtual Float_t GetZSTARS(Int_t index1, Int_t index2) const; | |
245 | ||
246 | virtual void SetIHTYPE(Int_t val); | |
247 | virtual void SetIHTYPE(Char_t val[]); | |
248 | virtual Int_t GetIHTYPE() const; | |
249 | ||
250 | virtual Float_t GetHGAMSS(Int_t index1, Int_t index2) const; | |
251 | ||
252 | // Ends HCON | |
253 | // Common block JETLIM access routines | |
254 | ||
255 | virtual void SetPMIN(Float_t val, Int_t index); | |
256 | virtual void SetAllPMIN(const Float_t val[], Int_t arraySize); | |
257 | virtual Float_t GetPMIN(Int_t index) const; | |
258 | ||
259 | virtual void SetPMAX(Float_t val, Int_t index); | |
260 | virtual void SetAllPMAX(const Float_t val[], Int_t arraySize); | |
261 | virtual Float_t GetPMAX(Int_t index) const; | |
262 | ||
263 | virtual void SetPTMIN(Float_t val, Int_t index); | |
264 | virtual void SetAllPTMIN(const Float_t val[], Int_t arraySize); | |
265 | virtual Float_t GetPTMIN(Int_t index) const; | |
266 | ||
267 | virtual void SetPTMAX(Float_t val, Int_t index); | |
268 | virtual void SetAllPTMAX(const Float_t val[], Int_t arraySize); | |
269 | virtual Float_t GetPTMAX(Int_t index) const; | |
270 | ||
271 | virtual void SetYJMIN(Float_t val, Int_t index); | |
272 | virtual void SetAllYJMIN(const Float_t val[], Int_t arraySize); | |
273 | virtual Float_t GetYJMIN(Int_t index) const; | |
274 | ||
275 | virtual void SetYJMAX(Float_t val, Int_t index); | |
276 | virtual void SetAllYJMAX(const Float_t val[], Int_t arraySize); | |
277 | virtual Float_t GetYJMAX(Int_t index) const; | |
278 | ||
279 | virtual void SetYJLIMS(); | |
280 | ||
281 | // YJMIN and YJMAX default to a function of PTMIN; but if either has | |
282 | // been set by hand, SetYJLIMS is not called when PTMIN is set. | |
283 | ||
284 | virtual void SetPHIMIN(Float_t val, Int_t index); | |
285 | virtual void SetAllPHIMIN(const Float_t val[], Int_t arraySize); | |
286 | virtual Float_t GetPHIMIN(Int_t index) const; | |
287 | ||
288 | virtual void SetPHIMAX(Float_t val, Int_t index); | |
289 | virtual void SetAllPHIMAX(const Float_t val[], Int_t arraySize); | |
290 | virtual Float_t GetPHIMAX(Int_t index) const; | |
291 | ||
292 | virtual void SetXJMIN(Float_t val, Int_t index); | |
293 | virtual void SetAllXJMIN(const Float_t val[], Int_t arraySize); | |
294 | virtual Float_t GetXJMIN(Int_t index) const; | |
295 | ||
296 | virtual void SetXJMAX(Float_t val, Int_t index); | |
297 | virtual void SetAllXJMAX(const Float_t val[], Int_t arraySize); | |
298 | virtual Float_t GetXJMAX(Int_t index) const; | |
299 | ||
300 | virtual void SetTHMIN(Float_t val, Int_t index); | |
301 | virtual void SetAllTHMIN(const Float_t val[], Int_t arraySize); | |
302 | virtual Float_t GetTHMIN(Int_t index) const; | |
303 | ||
304 | virtual void SetTHLIMS(); | |
305 | ||
306 | virtual void SetTHMAX(Float_t val, Int_t index); | |
307 | virtual void SetAllTHMAX(const Float_t val[], Int_t arraySize); | |
308 | virtual Float_t GetTHMAX(Int_t index) const; | |
309 | ||
310 | virtual Bool_t GetSETLMJ(Int_t index) const; | |
311 | ||
312 | // Ends JETLIM | |
313 | // Common block JETPAR access routines | |
314 | ||
315 | virtual Float_t GetP(Int_t index) const; | |
316 | ||
317 | virtual Float_t GetPT(Int_t index) const; | |
318 | ||
319 | virtual Float_t GetYJ(Int_t index) const; | |
320 | ||
321 | virtual Float_t GetPHI(Int_t index) const; | |
322 | ||
323 | virtual Float_t GetXJ(Int_t index) const; | |
324 | ||
325 | virtual Float_t GetTH(Int_t index) const; | |
326 | ||
327 | virtual Float_t GetCTH(Int_t index) const; | |
328 | ||
329 | virtual Float_t GetSTH(Int_t index) const; | |
330 | ||
331 | virtual Int_t GetJETTYP(Int_t index) const; | |
332 | ||
333 | virtual Float_t GetSHAT() const; | |
334 | ||
335 | virtual Float_t GetTHAT() const; | |
336 | ||
337 | virtual Float_t GetUHAT() const; | |
338 | ||
339 | virtual Float_t GetQSQ() const; | |
340 | ||
341 | virtual Float_t GetX1() const; | |
342 | ||
343 | virtual Float_t GetX2() const; | |
344 | ||
345 | virtual Float_t GetPBEAM(Int_t index) const; | |
346 | ||
347 | virtual Float_t GetQMW() const; | |
348 | ||
349 | virtual Float_t GetQW() const; | |
350 | ||
351 | virtual Float_t GetQTW() const; | |
352 | ||
353 | virtual Float_t GetYW() const; | |
354 | ||
355 | virtual Float_t GetXW() const; | |
356 | ||
357 | virtual Float_t GetTHW() const; | |
358 | ||
359 | virtual Float_t GetQTMW() const; | |
360 | ||
361 | virtual Float_t GetPHIW() const; | |
362 | ||
363 | virtual Float_t GetSHAT1() const; | |
364 | ||
365 | virtual Float_t GetTHAT1() const; | |
366 | ||
367 | virtual Float_t GetUHAT1() const; | |
368 | ||
369 | virtual void SetJWTYP(Int_t val); | |
370 | virtual void SetJWTYP(Char_t val[]); | |
371 | virtual Int_t GetJWTYP() const; | |
372 | ||
373 | virtual Float_t GetALFQSQ() const; | |
374 | ||
375 | virtual Float_t GetCTHW() const; | |
376 | ||
377 | virtual Float_t GetSTHW() const; | |
378 | ||
379 | virtual Float_t GetQ0W() const; | |
380 | ||
381 | virtual Int_t GetINITYP(Int_t index) const; | |
382 | ||
383 | virtual Int_t GetISIGS() const; | |
384 | ||
385 | virtual Float_t GetPBEAMS(Int_t index) const; | |
386 | ||
387 | // Ends JETPAR | |
388 | // Common block KKGRAV access routines | |
389 | ||
390 | virtual void SetNEXTRAD(Int_t val); | |
391 | virtual Int_t GetNEXTRAD() const; | |
392 | ||
393 | virtual void SetMASSD(Float_t val); | |
394 | virtual Float_t GetMASSD() const; | |
395 | ||
396 | virtual Float_t GetKKGSD() const; | |
397 | ||
398 | virtual Float_t GetSURFD() const; | |
399 | ||
400 | virtual void SetUVCUT(Bool_t val); | |
401 | virtual Bool_t GetUVCUT() const; | |
402 | ||
403 | // Ends KKGRAV | |
404 | // Common block MBGEN access routines | |
405 | ||
406 | virtual Float_t GetPOMWT(Int_t index) const; | |
407 | ||
408 | virtual Float_t GetPOMGEN(Int_t index) const; | |
409 | ||
410 | virtual void SetMNPOM(Int_t val); | |
411 | virtual Int_t GetMNPOM() const; | |
412 | ||
413 | virtual void SetMXPOM(Int_t val); | |
414 | virtual Int_t GetMXPOM() const; | |
415 | ||
416 | virtual Float_t GetPDIFFR() const; | |
417 | ||
418 | virtual Int_t GetNPOM() const; | |
419 | ||
420 | virtual Float_t GetXBARY(Int_t index) const; | |
421 | ||
422 | virtual Float_t GetDXBARY(Int_t index) const; | |
423 | ||
424 | virtual Float_t GetXPOM(Int_t index1, Int_t index2) const; | |
425 | ||
426 | // Ends MBGEN | |
427 | // Common block MGLIMS access routines | |
428 | ||
429 | virtual void SetEHMGMN(Float_t val); | |
430 | virtual Float_t GetEHMGMN() const; | |
431 | ||
432 | virtual void SetEHMGMX(Float_t val); | |
433 | virtual Float_t GetEHMGMX() const; | |
434 | ||
435 | virtual Float_t GetYHMGMN() const; | |
436 | ||
437 | virtual Float_t GetYHMGMX() const; | |
438 | ||
439 | // The eights in the All-setters correspond to MGLIMS.mxlim, but the | |
440 | // compiler will not recognize it here. | |
441 | ||
442 | virtual void SetAMIJMN(Float_t val, Int_t index1, Int_t index2); | |
443 | virtual void SetAllAMIJMN(const Float_t val[8][8]); | |
444 | virtual void SetColumnAMIJMN(const Float_t val[], Int_t col); | |
445 | virtual Float_t GetAMIJMN(Int_t index1, Int_t index2) const; | |
446 | ||
447 | virtual void SetAMIJMX(Float_t val, Int_t index1, Int_t index2); | |
448 | virtual void SetAllAMIJMX(const Float_t val[8][8]); | |
449 | virtual void SetColumnAMIJMX(const Float_t val[], Int_t col); | |
450 | virtual Float_t GetAMIJMX(Int_t index1, Int_t index2) const; | |
451 | ||
452 | virtual Bool_t GetFIXMIJ(Int_t index1, Int_t index2) const; | |
453 | ||
454 | // End MGLIMS | |
455 | // Common block NODCAY access routines | |
456 | ||
457 | virtual void SetNODCAY(Bool_t val); | |
458 | virtual Bool_t GetNODCAY() const; | |
459 | ||
460 | virtual void SetNOETA(Bool_t val); | |
461 | virtual Bool_t GetNOETA() const; | |
462 | ||
463 | virtual void SetNOPI0(Bool_t val); | |
464 | virtual Bool_t GetNOPI0() const; | |
465 | ||
466 | virtual void SetNONUNU(Bool_t val); | |
467 | virtual Bool_t GetNONUNU() const; | |
468 | ||
469 | virtual void SetNOEVOL(Bool_t val); | |
470 | virtual Bool_t GetNOEVOL() const; | |
471 | ||
472 | virtual void SetNOHADR(Bool_t val); | |
473 | virtual Bool_t GetNOHADR() const; | |
474 | ||
475 | virtual void SetNOGRAV(Bool_t val); | |
476 | virtual Bool_t GetNOGRAV() const; | |
477 | ||
478 | // Ends NODCAY | |
479 | // Common block PARTCL access routines (get-only block) | |
480 | ||
481 | virtual Int_t GetNPTCL() const; | |
482 | ||
483 | virtual Float_t GetPX(Int_t index) const; | |
484 | virtual Float_t GetPY(Int_t index) const; | |
485 | virtual Float_t GetPZ(Int_t index) const; | |
486 | virtual Float_t GetP0(Int_t index) const; | |
487 | virtual Float_t GetMASS(Int_t index) const; | |
488 | ||
489 | virtual Float_t GetORIG(Int_t index) const; | |
490 | virtual Float_t GetIDENT(Int_t index) const; | |
491 | virtual Float_t GetIDCAY(Int_t index) const; | |
492 | ||
493 | // Ends PARTCL | |
494 | // Common block PRIMAR access routines | |
495 | ||
496 | virtual Int_t GetNJET() const; | |
497 | ||
498 | virtual Float_t GetSCM() const; | |
499 | ||
500 | virtual Float_t GetHALFE() const; | |
501 | ||
502 | virtual void SetECM(Float_t val); | |
503 | virtual Float_t GetECM() const; | |
504 | ||
505 | virtual void SetIDIN(Int_t val, Int_t index); | |
506 | virtual void SetIDIN(const Char_t val[], Int_t index); | |
507 | virtual Int_t GetIDIN(Int_t index) const; | |
508 | ||
509 | virtual Int_t GetNEVENT() const; | |
510 | ||
511 | virtual void SetNTRIES(Int_t val); | |
512 | virtual Int_t GetNTRIES() const; | |
513 | ||
514 | virtual void SetNSIGMA(Int_t val); | |
515 | virtual Int_t GetNSIGMA()const; | |
516 | ||
517 | // Ends PRIMAR | |
518 | // Common block QCDPAR access routines | |
519 | ||
520 | virtual void SetALAM(Float_t val); | |
521 | virtual Float_t GetALAM() const; | |
522 | ||
523 | virtual Float_t GetALAM2() const; | |
524 | ||
525 | virtual void SetCUTJET(Float_t val); | |
526 | virtual Float_t GetCUTJET() const; | |
527 | ||
528 | virtual void SetISTRUC(Int_t val); | |
529 | virtual void SetISTRUC(const Char_t val[]); | |
530 | virtual Int_t GetISTRUC() const; | |
531 | ||
532 | // Ends QCDPAR | |
533 | // Common block QLMASS access routines | |
534 | ||
535 | // AMLEP has no All-setter for the good and simple reason that | |
536 | // not all of its entries should be set. GetAnyAMLEP returns those | |
537 | // indices that cannot be set by the user. | |
538 | ||
539 | ||
540 | virtual void SetAMLEP(Float_t val, Int_t index); | |
541 | virtual Float_t GetAnyAMLEP(Int_t index) const; | |
542 | virtual Float_t GetAMLEP(Int_t index) const; | |
543 | ||
544 | virtual void SetTquarkMass(Float_t val); | |
545 | virtual Float_t GetTquarkMass() const; | |
546 | ||
547 | virtual void SetXquarkMass(Float_t val); | |
548 | virtual Float_t GetXquarkMass() const; | |
549 | ||
550 | virtual void SetYquarkMass(Float_t val); | |
551 | virtual Float_t GetYquarkMass() const; | |
552 | ||
553 | virtual void SetUtildeMass(Float_t val); | |
554 | virtual Float_t GetUtildeMass() const; | |
555 | ||
556 | virtual void SetDtildeMass(Float_t val); | |
557 | virtual Float_t GetDtildeMass() const; | |
558 | ||
559 | virtual void SetStildeMass(Float_t val); | |
560 | virtual Float_t GetStildeMass() const; | |
561 | ||
562 | virtual void SetCtildeMass(Float_t val); | |
563 | virtual Float_t GetCtildeMass() const; | |
564 | ||
565 | virtual void SetBtildeMass(Float_t val); | |
566 | virtual Float_t GetBtildeMass() const; | |
567 | ||
568 | virtual void SetTtildeMass(Float_t val); | |
569 | virtual Float_t GetTtildeMass() const; | |
570 | ||
571 | virtual void SetGtildeMass(Float_t val); | |
572 | virtual Float_t GetGtildeMass() const; | |
573 | ||
574 | virtual void SetGammatildeMass(Float_t val); | |
575 | virtual Float_t GetGammatildeMass() const; | |
576 | ||
577 | virtual void SetNuEtildeMass(Float_t val); | |
578 | virtual Float_t GetNuEtildeMass() const; | |
579 | ||
580 | virtual void SetEtildeMass(Float_t val); | |
581 | virtual Float_t GetEtildeMass() const; | |
582 | ||
583 | virtual void SetNuMutildeMass(Float_t val); | |
584 | virtual Float_t GetNuMutildeMass() const; | |
585 | ||
586 | virtual void SetMutildeMass(Float_t val); | |
587 | virtual Float_t GetMutildeMass() const; | |
588 | ||
589 | virtual void SetNuTautildeMass(Float_t val); | |
590 | virtual Float_t GetNuTautildeMass() const; | |
591 | ||
592 | virtual void SetTautildeMass(Float_t val); | |
593 | virtual Float_t GetTautildeMass() const; | |
594 | ||
595 | virtual void SetWplustildeMass(Float_t val); | |
596 | virtual Float_t GetWplustildeMass() const; | |
597 | ||
598 | virtual void SetZ0tildeMass(Float_t val); | |
599 | virtual Float_t GetZ0tildeMass() const; | |
600 | ||
601 | virtual void SetHiggsMesonMass(Float_t val, Int_t index); | |
602 | virtual Float_t GetHiggsMesonMass(Int_t index) const; | |
603 | ||
604 | virtual Int_t GetNQLEP() const; | |
605 | ||
606 | virtual Int_t GetNMES() const; | |
607 | ||
608 | virtual Int_t GetNBARY() const; | |
609 | ||
610 | // Ends QLMASS | |
611 | // Common block SEED access routines | |
612 | ||
613 | virtual void SetSEED(const Char_t val[24]); | |
614 | virtual Char_t* GetSEED() const; | |
615 | ||
616 | // Ends SEED | |
617 | // Common block SUGNU access routines | |
618 | ||
619 | virtual void SetXNUSUG(Float_t val, Int_t index); | |
620 | virtual Float_t GetXNUSUG(Int_t index) const; | |
621 | ||
622 | virtual void SetGauginoMass(Float_t val, Int_t index); | |
623 | virtual Float_t GetGauginoMass(Int_t index) const; | |
624 | ||
625 | virtual void SetAtau(Float_t val); | |
626 | virtual Float_t GetAtau() const; | |
627 | ||
628 | virtual void SetAb(Float_t val); | |
629 | virtual Float_t GetAb() const; | |
630 | ||
631 | virtual void SetAt(Float_t val); | |
632 | virtual Float_t GetAt() const; | |
633 | ||
634 | virtual void SetHiggsDmass(Float_t val); | |
635 | virtual Float_t GetHiggsDmass() const; | |
636 | ||
637 | virtual void SetHiggsUmass(Float_t val); | |
638 | virtual Float_t GetHiggsUmass() const; | |
639 | ||
640 | virtual void SetERmass(Float_t val); | |
641 | virtual Float_t GetERmass() const; | |
642 | ||
643 | virtual void SetELmass(Float_t val); | |
644 | virtual Float_t GetELmass() const; | |
645 | ||
646 | virtual void SetDRmass(Float_t val); | |
647 | virtual Float_t GetDRmass() const; | |
648 | ||
649 | virtual void SetURmass(Float_t val); | |
650 | virtual Float_t GetURmass() const; | |
651 | ||
652 | virtual void SetULmass(Float_t val); | |
653 | virtual Float_t GetULmass() const; | |
654 | ||
655 | virtual void SetTauRmass(Float_t val); | |
656 | virtual Float_t GetTauRmass() const; | |
657 | ||
658 | virtual void SetTauLmass(Float_t val); | |
659 | virtual Float_t GetTauLmass() const; | |
660 | ||
661 | virtual void SetBRmass(Float_t val); | |
662 | virtual Float_t GetBRmass() const; | |
663 | ||
664 | virtual void SetTRmass(Float_t val); | |
665 | virtual Float_t GetTRmass() const; | |
666 | ||
667 | virtual void SetTLmass(Float_t val); | |
668 | virtual Float_t GetTLmass() const; | |
669 | ||
670 | // Ends XNUSUG | |
671 | // Common block TCPAR access routines | |
672 | ||
673 | virtual void SetTCMRHO(Float_t val); | |
674 | virtual Float_t GetTCMRHO() const; | |
675 | ||
676 | virtual void SetTCGRHO(Float_t val); | |
677 | virtual Float_t GetTCGRHO() const; | |
678 | ||
679 | // Ends TCPAR | |
680 | // Common block TYPES access routines | |
681 | ||
682 | virtual Int_t GetLOC(Int_t index) const; | |
683 | ||
684 | virtual Int_t GetNTYP() const; | |
685 | ||
686 | virtual Int_t GetNJTTYP(Int_t index) const; | |
687 | ||
688 | virtual Int_t GetNWWTYP(Int_t index) const; | |
689 | ||
690 | virtual Int_t GetNWMODE(Int_t index) const; | |
691 | ||
692 | // Ends TYPES | |
693 | // Common block XMSSM access routines | |
694 | ||
695 | virtual Bool_t GetGOMSSM() const; | |
696 | ||
697 | virtual Bool_t GetGOSUG() const; | |
698 | ||
699 | virtual Bool_t GetGOGMSB() const; | |
700 | ||
701 | virtual Bool_t GetGOAMSB() const; | |
702 | ||
703 | virtual Bool_t GetAL3UNI() const; | |
704 | ||
705 | virtual void SetXGLSS(Float_t val); | |
706 | virtual Float_t GetXGLSS() const; | |
707 | ||
708 | virtual void SetXMUSS(Float_t val); | |
709 | virtual Float_t GetXMUSS() const; | |
710 | ||
711 | virtual void SetXHASS(Float_t val); | |
712 | virtual Float_t GetXHASS() const; | |
713 | ||
714 | virtual void SetXTBSS(Float_t val); | |
715 | virtual Float_t GetXTBSS() const; | |
716 | ||
717 | virtual void SetXQ1SS(Float_t val); | |
718 | virtual Float_t GetXQ1SS() const; | |
719 | ||
720 | virtual void SetXDRSS(Float_t val); | |
721 | virtual Float_t GetXDRSS() const; | |
722 | ||
723 | virtual void SetXURSS(Float_t val); | |
724 | virtual Float_t GetXURSS() const; | |
725 | ||
726 | virtual void SetXL1SS(Float_t val); | |
727 | virtual Float_t GetXL1SS() const; | |
728 | ||
729 | virtual void SetXERSS(Float_t val); | |
730 | virtual Float_t GetXERSS() const; | |
731 | ||
732 | virtual void SetXQ2SS(Float_t val); | |
733 | virtual Float_t GetXQ2SS() const; | |
734 | ||
735 | virtual void SetXSRSS(Float_t val); | |
736 | virtual Float_t GetXSRSS() const; | |
737 | ||
738 | virtual void SetXCRSS(Float_t val); | |
739 | virtual Float_t GetXCRSS() const; | |
740 | ||
741 | virtual void SetXL2SS(Float_t val); | |
742 | virtual Float_t GetXL2SS() const; | |
743 | ||
744 | virtual void SetXMRSS(Float_t val); | |
745 | virtual Float_t GetXMRSS() const; | |
746 | ||
747 | virtual void SetXQ3SS(Float_t val); | |
748 | virtual Float_t GetXQ3SS() const; | |
749 | ||
750 | virtual void SetXBRSS(Float_t val); | |
751 | virtual Float_t GetXBRSS() const; | |
752 | ||
753 | virtual void SetXTRSS(Float_t val); | |
754 | virtual Float_t GetXTRSS() const; | |
755 | ||
756 | virtual void SetXL3SS(Float_t val); | |
757 | virtual Float_t GetXL3SS() const; | |
758 | ||
759 | virtual void SetXTARSS(Float_t val); | |
760 | virtual Float_t GetXTARSS() const; | |
761 | ||
762 | virtual void SetXATSS(Float_t val); | |
763 | virtual Float_t GetXATSS() const; | |
764 | ||
765 | virtual void SetXABSS(Float_t val); | |
766 | virtual Float_t GetXABSS() const; | |
767 | ||
768 | virtual void SetXATASS(Float_t val); | |
769 | virtual Float_t GetXATASS() const; | |
770 | ||
771 | virtual void SetXM1SS(Float_t val); | |
772 | virtual Float_t GetXM1SS() const; | |
773 | ||
774 | virtual void SetXM2SS(Float_t val); | |
775 | virtual Float_t GetXM2SS() const; | |
776 | ||
777 | virtual void SetXM0SU(Float_t val); | |
778 | virtual Float_t GetXM0SU() const; | |
779 | ||
780 | virtual void SetXMHSU(Float_t val); | |
781 | virtual Float_t GetXMHSU() const; | |
782 | ||
783 | virtual void SetXA0SU(Float_t val); | |
784 | virtual Float_t GetXA0SU() const; | |
785 | ||
786 | virtual void SetXTGBSU(Float_t val); | |
787 | virtual Float_t GetXTGBSU() const; | |
788 | ||
789 | virtual void SetXSMUSU(Float_t val); | |
790 | virtual Float_t GetXSMUSU() const; | |
791 | ||
792 | virtual void SetXLAMGM(Float_t val); | |
793 | virtual Float_t GetXLAMGM() const; | |
794 | ||
795 | virtual void SetXMESGM(Float_t val); | |
796 | virtual Float_t GetXMESGM() const; | |
797 | ||
798 | virtual void SetXN5GM(Float_t val); | |
799 | virtual Float_t GetXN5GM() const; | |
800 | ||
801 | virtual void SetXCMGV(Float_t val); | |
802 | virtual Float_t GetXCMGV() const; | |
803 | ||
804 | virtual void SetMGVTO(Float_t val); | |
805 | virtual Float_t GetMGVTO() const; | |
806 | ||
807 | virtual void SetXRSLGM(Float_t val); | |
808 | virtual Float_t GetXRSLGM() const; | |
809 | ||
810 | virtual void SetXDHDGM(Float_t val); | |
811 | virtual Float_t GetXDHDGM() const; | |
812 | ||
813 | virtual void SetXDHUGM(Float_t val); | |
814 | virtual Float_t GetXDHUGM() const; | |
815 | ||
816 | virtual void SetXDYGM(Float_t val); | |
817 | virtual Float_t GetXDYGM() const; | |
818 | ||
819 | virtual void SetXN51GM(Float_t val); | |
820 | virtual Float_t GetXN51GM() const; | |
821 | ||
822 | virtual void SetXN52GM(Float_t val); | |
823 | virtual Float_t GetXN52GM() const; | |
824 | ||
825 | virtual void SetXN53GM(Float_t val); | |
826 | virtual Float_t GetXN53GM() const; | |
827 | ||
828 | virtual void SetXMN3NR(Float_t val); | |
829 | virtual Float_t GetXMN3NR() const; | |
830 | ||
831 | virtual void SetXMAJNR(Float_t val); | |
832 | virtual Float_t GetXMAJNR() const; | |
833 | ||
834 | virtual void SetXANSS(Float_t val); | |
835 | virtual Float_t GetXANSS() const; | |
836 | ||
837 | virtual void SetXNRSS(Float_t val); | |
838 | virtual Float_t GetXNRSS() const; | |
839 | ||
840 | virtual void SetXSBCS(Float_t val); | |
841 | virtual Float_t GetXSBCS() const; | |
842 | ||
843 | // Ends XMSSM | |
844 | // Common block XTYPES access routines | |
845 | ||
846 | virtual Char_t* GetPARTYP(Int_t index) const; | |
847 | ||
848 | virtual void SetTITLE(Char_t *val); | |
849 | virtual Char_t* GetTITLE() const; | |
850 | ||
851 | virtual void SetJETYP(Int_t index, Char_t val[]); | |
852 | virtual Char_t* GetJETYP(Int_t index1, Int_t index2) const; | |
853 | ||
854 | virtual void SetWWTYP(Char_t val[], Int_t index1, Int_t index2); | |
855 | virtual void SetAllWWTYP(Char_t* val[2][30]); | |
856 | virtual void SetColumnWWTYP(Char_t* val[], Int_t col); | |
857 | virtual Char_t* GetWWTYP(Int_t index1, Int_t index2) const; | |
858 | ||
859 | virtual void SetWMODES(Char_t val[], Int_t index1, Int_t index2); | |
860 | virtual void SetAllWMODES(Char_t* val[2][30]); | |
861 | virtual void SetColumnWMODES(Char_t* val[], Int_t col); | |
862 | virtual Char_t* GetWMODES(Int_t index1, Int_t index2) const; | |
863 | ||
864 | // Ends XTYPES | |
865 | // Common block WCON access routines | |
866 | ||
867 | virtual void SetSIN2W(Float_t val); | |
868 | virtual Float_t GetSIN2W() const; | |
869 | ||
870 | virtual void SetWMASS(Float_t w, Float_t z); | |
871 | virtual Float_t GetWMASS(Int_t index) const; | |
872 | ||
873 | virtual void SetWMass(Float_t val); | |
874 | ||
875 | virtual void SetZMass(Float_t val); | |
876 | ||
877 | ||
878 | virtual Float_t GetWGAM(Int_t index) const; | |
879 | ||
880 | virtual Float_t GetAQ(Int_t index1, Int_t index2) const; | |
881 | ||
882 | virtual Float_t GetBQ(Int_t index1, Int_t index2) const; | |
883 | ||
884 | virtual Float_t GetCOUT(Int_t index) const; | |
885 | ||
886 | virtual Int_t GetMATCH() const; | |
887 | ||
888 | virtual Float_t GetWCBR(Int_t index1, Int_t index2) const; | |
889 | ||
890 | virtual void SetCUTOFF(Float_t val); | |
891 | virtual Float_t GetCUTOFF() const; | |
892 | ||
893 | virtual void SetCUTPOW(Float_t val); | |
894 | virtual Float_t GetCUTPOW() const; | |
895 | ||
896 | virtual Float_t GetTBRWW(Int_t index1, Int_t index2) const; | |
897 | ||
898 | virtual Float_t GetRBRWW(Int_t index1, Int_t index2, Int_t index3) const; | |
899 | ||
900 | virtual Float_t GetEZ() const; | |
901 | ||
902 | virtual Float_t GetAQDP(Int_t index1, Int_t index2) const; | |
903 | ||
904 | virtual Float_t GetBQDP(Int_t index1, Int_t index2) const; | |
905 | ||
906 | virtual Float_t GetEZDP() const; | |
907 | ||
908 | virtual void SetWFUDGE(Float_t val); | |
909 | virtual Float_t GetWFUDGE() const; | |
910 | ||
911 | // Ends WCON | |
912 | ||
913 | ClassDef(TIsajet,1) | |
914 | }; | |
915 | ||
916 | ||
917 | ||
918 | #endif | |
919 | ||
920 | // Endfile. | |
921 | ||
922 |