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