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 | |
79 | virtual void PDFinit(); |
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 | |