Initial import
[u/mrichter/AliRoot.git] / AliFluka / TFluka.cxx
1 // $Id$
2 // Category: run
3 //
4 // See the class description in the header file.
5
6 #include "TFluka.h"
7
8 #include "TG4Globals.h"
9 #include "TG4GeometryManager.h" 
10
11 #include "AliDecayer.h"
12
13 TFluka::TFluka(const char* name, const char* title)
14   : AliMC(name, title)
15 {
16   // create geometry manager
17   fGeometryManager = new TG4GeometryManager();
18   // add verbose level
19   //G4cout << "TG4GeometryManager has been created." << endl;
20 }
21     
22 TFluka::TFluka() {
23 //
24 }
25
26 TFluka::TFluka(const TFluka& right) {
27 // 
28   TG4Globals::Exception("TFluka is protected from copying.");
29 }
30
31 TFluka::~TFluka() {
32 //
33   delete fGeometryManager;
34 }
35
36 // operators
37
38 TFluka& TFluka::operator=(const TFluka& right)
39 {
40   // check assignement to self
41   if (this == &right) return *this;
42
43   TG4Globals::Exception("TFluka is protected from assigning.");
44     
45   return *this;  
46 }    
47           
48
49 // methods for building/management of geometry
50 // ------------------------------------------------
51
52 void TFluka::FinishGeometry() {
53 //
54   fGeometryManager->Ggclos();
55
56
57 void TFluka::Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,  
58                          Float_t &dens, Float_t &radl, Float_t &absl,
59                          Float_t* ubuf, Int_t& nbuf) {
60 //
61   fGeometryManager
62     ->Gfmate(imat, name, a, z, dens, radl, absl, ubuf, nbuf);
63
64
65 void TFluka::Material(Int_t& kmat, const char* name, Float_t a, 
66                      Float_t z, Float_t dens, Float_t radl, Float_t absl,
67                      Float_t* buf, Int_t nwbuf) {
68 //
69   fGeometryManager
70     ->Material(kmat, name, a, z, dens, radl, absl, buf, nwbuf); 
71
72
73 void TFluka::Mixture(Int_t& kmat, const char *name, Float_t *a, 
74                      Float_t *z, Float_t dens, Int_t nlmat, Float_t *wmat) {
75 //
76    fGeometryManager
77      ->Mixture(kmat, name, a, z, dens, nlmat, wmat); 
78
79
80 void TFluka::Medium(Int_t& kmed, const char *name, Int_t nmat, 
81                      Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd, 
82                      Float_t stemax, Float_t deemax, Float_t epsil, 
83                      Float_t stmin, Float_t* ubuf, Int_t nbuf) { 
84 //
85   fGeometryManager
86     ->Medium(kmed, name, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, 
87         epsil, stmin, ubuf, nbuf);
88
89
90 void TFluka::Matrix(Int_t& krot, Float_t thetaX, Float_t phiX, 
91                      Float_t thetaY, Float_t phiY, Float_t thetaZ, 
92                      Float_t phiZ) {
93 //                   
94   fGeometryManager
95     ->Matrix(krot, thetaX, phiX, thetaY, phiY, thetaZ, phiZ); 
96
97
98 void TFluka::Gstpar(Int_t itmed, const char *param, Float_t parval) {
99 //
100   fGeometryManager->Gstpar(itmed, param, parval); 
101 }    
102
103 Int_t TFluka::Gsvolu(const char *name, const char *shape, Int_t nmed,  
104                          Float_t *upar, Int_t np)  {
105 //
106   return fGeometryManager->Gsvolu(name, shape, nmed, upar, np); 
107 }
108  
109 void TFluka::Gsdvn(const char *name, const char *mother, Int_t ndiv, 
110                         Int_t iaxis) {
111 //
112   fGeometryManager->Gsdvn(name, mother, ndiv, iaxis); 
113
114
115 void TFluka::Gsdvn2(const char *name, const char *mother, Int_t ndiv, 
116                          Int_t iaxis, Float_t c0i, Int_t numed) {
117 //
118   fGeometryManager->Gsdvn2(name, mother, ndiv, iaxis, c0i, numed); 
119
120
121 void TFluka::Gsdvt(const char *name, const char *mother, Float_t step, 
122                         Int_t iaxis, Int_t numed, Int_t ndvmx) {
123 //                      
124   fGeometryManager->Gsdvt(name, mother, step, iaxis, numed, ndvmx); 
125
126
127 void TFluka::Gsdvt2(const char *name, const char *mother, Float_t step, 
128                          Int_t iaxis, Float_t c0, Int_t numed, Int_t ndvmx) { 
129 //
130   fGeometryManager->Gsdvt2(name, mother, step, iaxis, c0, numed, ndvmx); 
131
132
133 void TFluka::Gsord(const char *name, Int_t iax) {
134 //
135   fGeometryManager->Gsord(name, iax); 
136
137
138 void TFluka::Gspos(const char *name, Int_t nr, const char *mother,  
139                         Float_t x, Float_t y, Float_t z, Int_t irot, 
140                         const char *konly) {
141 //
142   fGeometryManager->Gspos(name, nr, mother, x, y, z, irot, konly); 
143
144
145 void TFluka::Gsposp(const char *name, Int_t nr, const char *mother,  
146                          Float_t x, Float_t y, Float_t z, Int_t irot,
147                          const char *konly, Float_t *upar, Int_t np)  {
148 //
149   fGeometryManager->Gsposp(name, nr, mother, x, y, z, irot, konly, upar, np); 
150
151
152 void TFluka::SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
153                   Float_t *absco, Float_t *effic, Float_t *rindex) {
154 //
155   fGeometryManager->SetCerenkov(itmed, npckov, ppckov, absco, effic, rindex);
156 }  
157     
158 void TFluka::WriteEuclid(const char* fileName, const char* topVol, 
159                           Int_t number, Int_t nlevel) {
160 //
161   fGeometryManager->WriteEuclid(fileName, topVol, number, nlevel); 
162
163                                
164 //======================================================================
165 //
166 // NOT IMPLEMENTED METHODS
167 //
168 //======================================================================
169
170 Int_t TFluka::VolId2Mate(Int_t id) const {
171 //
172   TG4Globals:: Warning("TFluka::VolId2Mate(..) is not implemented."); 
173   return 0; 
174
175
176 Int_t TFluka::VolId(const Text_t* volName) const {
177 //
178   TG4Globals:: Warning("TFluka::VolId(..) is not implemented."); 
179   return 0; 
180
181
182 const char* TFluka::VolName(Int_t id) const {
183 //
184   TG4Globals:: Warning("TFluka::VolName(..) is not implemented."); 
185   return 0; 
186 }
187  
188 Int_t TFluka::NofVolumes() const {
189 //
190   TG4Globals:: Warning("TFluka::NofVolumes(..) is not implemented."); 
191   return 0; 
192
193
194
195 // methods for physics management
196 // ------------------------------------------------
197  
198 void TFluka::BuildPhysics() {
199 //
200   TG4Globals:: Warning("TFluka::BuildPhysics(..) is not implemented."); 
201 }  
202
203 void TFluka::SetCut(const char* cutName, Float_t cutValue) { 
204 //
205   TG4Globals:: Warning("TFluka::SetCut(..) is not implemented."); 
206 }  
207
208 void TFluka::SetProcess(const char* flagName, Int_t flagValue) {
209 //
210   TG4Globals:: Warning("TFluka::SetProcess(..) is not implemented."); 
211 }  
212  
213 Float_t TFluka::Xsec(char* reac, Float_t energy, Int_t part, Int_t mate) {
214 //
215   TG4Globals:: Warning("TFluka::Xsec(..) is not implemented."); 
216   return 0;
217 }  
218
219 void TFluka::SetExternalDecayer(AliDecayer* decayer) {
220 //
221   TG4Globals:: Warning("TFluka::SetExternalDecayer(..) is not implemented."); 
222 }
223
224 AliDecayer* TFluka::Decayer() const {
225 //
226   TG4Globals:: Warning("TFluka::Decayer(..) is not implemented."); 
227   return 0; 
228 }
229   
230
231 Int_t TFluka::IdFromPDG(Int_t pdgID) const { 
232 //
233   TG4Globals:: Warning("TFluka::IdFromPDG(..) is not implemented."); 
234   return 0;
235 }  
236
237 Int_t TFluka::PDGFromId(Int_t mcID) const {
238 //
239   TG4Globals:: Warning("TFluka::PDGFromId(..) is not implemented."); 
240   return 0;
241 }  
242
243 void TFluka::DefineParticles() { 
244 //
245   TG4Globals:: Warning("TFluka::DefineParticles(..) is not implemented."); 
246 }  
247
248 // methods for step management
249 // ------------------------------------------------
250
251 void TFluka::StopTrack()
252
253   TG4Globals:: Warning("TFluka::StopTrack(..) is not implemented."); 
254
255
256 void TFluka::StopEvent()   
257
258   TG4Globals:: Warning("TFluka::StopEvent(..) is not implemented."); 
259
260
261 void TFluka::SetMaxStep(Float_t step)
262
263   TG4Globals:: Warning("TFluka::SetMaxStep(..) is not implemented."); 
264
265
266 void TFluka::SetMaxNStep(Int_t number)
267
268   TG4Globals:: Warning("TFluka::SetMaxNStep(..) is not implemented."); 
269
270
271 void TFluka::SetUserDecay(Int_t number)
272
273   TG4Globals:: Warning("TFluka::SetUserDecay(..) is not implemented."); 
274
275
276 Int_t TFluka::CurrentVolID(Int_t& copyNo) const
277
278   TG4Globals:: Warning("TFluka::CurrentVolID(..) is not implemented."); 
279   return 0;
280
281
282 Int_t TFluka::CurrentVolOffID(Int_t off, Int_t& copyNo) const
283
284   TG4Globals:: Warning("TFluka::CurrentVolOffID(..) is not implemented."); 
285   return 0;
286
287
288 const char* TFluka::CurrentVolName() const
289
290   TG4Globals:: Warning("TFluka::CurrentVolName(..) is not implemented."); 
291   return 0;
292
293
294 const char* TFluka::CurrentVolOffName(Int_t off) const
295
296   TG4Globals:: Warning("TFluka::CurrentVolOffName(..) is not implemented."); 
297   return 0;
298
299
300 Int_t TFluka::CurrentMaterial(Float_t &a, Float_t &z, 
301                     Float_t &dens, Float_t &radl, Float_t &absl) const  
302
303   TG4Globals:: Warning("TFluka::CurrentMaterial(..) is not implemented."); 
304   return 0;
305
306
307 void TFluka::Gmtod(Float_t* xm, Float_t* xd, Int_t iflag)
308
309   TG4Globals:: Warning("TFluka::Gmtod(..) is not implemented."); 
310
311
312 void TFluka::Gdtom(Float_t* xd, Float_t* xm, Int_t iflag)
313
314   TG4Globals:: Warning("TFluka::Gdtom(..) is not implemented."); 
315
316     
317 Float_t TFluka::MaxStep() const
318
319   TG4Globals:: Warning("TFluka::MaxStep(..) is not implemented."); 
320   return 0;
321
322
323 Int_t TFluka::GetMaxNStep() const
324
325   TG4Globals:: Warning("TFluka::GetMaxNStep(..) is not implemented."); 
326   return 0;
327
328
329 Int_t TFluka::GetMedium() const
330
331   TG4Globals:: Warning("TFluka::GetMedium(..) is not implemented."); 
332   return 0;
333
334
335 void TFluka::TrackPosition(TLorentzVector& position) const
336
337   TG4Globals:: Warning("TFluka::TrackPosition(..) is not implemented."); 
338
339
340 void TFluka::TrackMomentum(TLorentzVector& momentum) const
341
342   TG4Globals:: Warning("TFluka::TrackMomentum(..) is not implemented."); 
343
344
345 void TFluka::TrackVertexPosition(TLorentzVector& position) const
346
347   TG4Globals:: Warning("TFluka::TrackVertexPosition(..) is not implemented."); 
348
349
350 void TFluka::TrackVertexMomentum(TLorentzVector& momentum) const
351
352   TG4Globals:: Warning("TFluka::TrackVertexMomentum(..) is not implemented."); 
353
354
355 Float_t TFluka::TrackStep() const
356
357   TG4Globals:: Warning("TFluka::TrackStep(..) is not implemented."); 
358   return 0;
359
360
361 Float_t TFluka::TrackLength() const 
362
363   TG4Globals:: Warning("TFluka::TrackLength(..) is not implemented."); 
364   return 0; 
365
366
367 Float_t TFluka::TrackTime() const
368
369   TG4Globals:: Warning("TFluka::TrackTime(..) is not implemented."); 
370   return 0; 
371
372
373 Float_t TFluka::Edep() const
374
375   TG4Globals:: Warning("TFluka::Edep(..) is not implemented."); 
376   return 0; 
377
378
379 Int_t TFluka::TrackPid() const
380
381   TG4Globals:: Warning("TFluka::TrackPid(..) is not implemented."); 
382   return 0; 
383
384
385 Float_t TFluka::TrackCharge() const
386
387   TG4Globals:: Warning("TFluka::TrackCharge(..) is not implemented."); 
388   return 0; 
389
390
391 Float_t TFluka::TrackMass() const
392
393   TG4Globals:: Warning("TFluka::TrackMass(..) is not implemented."); 
394   return 0; 
395
396
397 Float_t TFluka::Etot() const
398
399   TG4Globals:: Warning("TFluka::Etot(..) is not implemented."); 
400   return 0; 
401
402
403 Bool_t  TFluka::IsTrackInside() const
404 {   
405   TG4Globals:: Warning("TFluka::IsTrackInside(..) is not implemented."); 
406   return false; 
407
408
409 Bool_t  TFluka::IsTrackEntering() const
410 {   
411   TG4Globals:: Warning("TFluka::IsTrackEntering(..) is not implemented."); 
412   return false; 
413
414
415 Bool_t  TFluka::IsTrackExiting() const
416 {   
417   TG4Globals:: Warning("TFluka::IsTrackExiting(..) is not implemented."); 
418   return false; 
419
420
421 Bool_t  TFluka::IsTrackOut() const
422 {   
423   TG4Globals:: Warning("TFluka::IsTrackOut(..) is not implemented."); 
424   return false; 
425
426
427 Bool_t  TFluka::IsTrackDisappeared() const
428 {   
429   TG4Globals:: Warning("TFluka::IsTrackDisappeared(..) is not implemented."); 
430   return false; 
431
432
433 Bool_t  TFluka::IsTrackStop() const
434 {  
435   TG4Globals:: Warning("TFluka::IsTrackStop(..) is not implemented."); 
436   return false; 
437
438
439 Bool_t  TFluka::IsTrackAlive() const
440 {   
441   TG4Globals:: Warning("TFluka::IsTrackAlive(..) is not implemented."); 
442   return false; 
443
444
445 Bool_t TFluka::IsNewTrack() const
446 {
447   TG4Globals:: Warning("TFluka::IsNewTrack(..) is not implemented."); 
448   return false;
449 }  
450
451 Int_t TFluka::NSecondaries() const
452
453   TG4Globals:: Warning("TFluka::NSecondaries(..) is not implemented."); 
454   return 0; 
455
456
457 void  TFluka::GetSecondary(Int_t isec, Int_t& particleId, 
458                          TLorentzVector& position, TLorentzVector& momentum)
459
460   TG4Globals:: Warning("TFluka::GetSecondary(..) is not implemented."); 
461
462
463 AliMCProcess TFluka::ProdProcess(Int_t isec) const 
464
465   TG4Globals:: Warning("TFluka::ProdProcess(..) is not implemented."); 
466   return kPNoProcess; 
467
468
469 Int_t TFluka::StepProcesses(TArrayI &proc) const
470
471   TG4Globals:: Warning("TFluka::StepProcesses(..) is not implemented."); 
472   return 0; 
473
474
475 // methods for visualization
476 // ------------------------------------------------
477
478 void TFluka::DrawOneSpec(const char* name) {
479 //
480   TG4Globals:: Warning("TFluka::DrawOneSpec(): no visualization available."); 
481
482
483 void TFluka::Gsatt(const char* name, const char* att, Int_t val) {
484 //
485   TG4Globals:: Warning("TFluka::Gsatt(): no visualization available."); 
486
487
488 void TFluka::Gdraw(const char* p1, Float_t theta, Float_t phi,
489                         Float_t psi, Float_t u0, Float_t v0,
490                         Float_t ul, Float_t vl) {
491 //
492   TG4Globals:: Warning("TFluka::Gdraw(): no visualization available."); 
493
494
495
496 // methods for run control
497 // ------------------------------------------------
498
499 void TFluka::Init() { 
500 //
501   TG4Globals:: Warning("TFluka::Init(..) is not implemented."); 
502 }  
503   
504 void TFluka::ProcessEvent() { 
505 //
506   TG4Globals:: Warning("TFluka::ProcessEvent(..) is not implemented."); 
507 }  
508
509 void TFluka::ProcessRun(Int_t nofEvents) {
510 //
511   TG4Globals:: Warning("TFluka::ProcessRun(..) is not implemented."); 
512 }  
513
514 Int_t TFluka::CurrentEvent() const {
515 //
516   TG4Globals:: Warning("TFluka::CurrentEvent(..) is not implemented."); 
517   return 0;
518
519
520 // Geant3 specific methods
521 // !!! need to be transformed to common interface
522 // ------------------------------------------------
523     
524 void TFluka::Gdopt(const char* name, const char* value) {
525 //
526   TG4Globals:: Warning("TFluka::Gdopt(..) is not implemented."); 
527 }
528
529 void TFluka::SetClipBox(const char *name, Float_t xmin, Float_t xmax,
530                      Float_t ymin, Float_t ymax, Float_t zmin, Float_t zmax) { 
531 //
532   TG4Globals:: Warning("TFluka::SetClipBox(..) is not implemented."); 
533 }
534
535 void TFluka::DefaultRange() { 
536 //
537   TG4Globals:: Warning("TFluka::DefaultRange() is not implemented."); 
538 }
539
540 void TFluka::Gdhead(Int_t isel, const char* name, Float_t chrsiz) { 
541 //
542   TG4Globals:: Warning("TFluka::Gdhead(..) is not implemented."); 
543 }
544
545 void TFluka::Gdman(Float_t u, Float_t v, const char* type) { 
546 //
547   TG4Globals:: Warning("TFluka::Gdman(..) is not implemented."); 
548 }
549
550 void TFluka::SetColors() { 
551 //
552   TG4Globals:: Warning("TFluka::SetColours() is not implemented."); 
553 }
554
555 void TFluka::Gtreve() { 
556 //
557   TG4Globals:: Warning("TFluka::Gtreve() is not implemented."); 
558 }
559
560 void TFluka::GtreveRoot() { 
561 //
562   TG4Globals:: Warning("TFluka::GtreveRoot() is not implemented."); 
563 }
564
565 void TFluka::Gckmat(Int_t itmed, char* natmed) { 
566 //
567   TG4Globals:: Warning("TFluka::Gckmat(..) is not implemented."); 
568 }
569
570 void TFluka::InitLego() { 
571 //
572   TG4Globals:: Warning("TFluka::InitLego() is not implemented."); 
573 }
574
575 void TFluka::Gfpart(Int_t ipart, char *name, Int_t& itrtyp,  
576                      Float_t& amass, Float_t& charge, Float_t& tlife) { 
577 //
578   TG4Globals:: Warning("TFluka::Gfpart(..) is not implemented."); 
579 }
580
581 void TFluka::Gspart(Int_t ipart, const char *name, Int_t itrtyp,  
582                      Float_t amass, Float_t charge, Float_t tlife) {  
583 //
584   TG4Globals:: Warning("TFluka::Gspart(..) is not implemented."); 
585 }