Fixed compiling error for HP (multiple declaration)
[u/mrichter/AliRoot.git] / RICH / AliRICHv1.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 /*
17   $Log$
18   Revision 1.2  2000/06/12 15:36:16  jbarbosa
19   Cleaned up version.
20
21   Revision 1.1  2000/06/09 15:00:31  jbarbosa
22   New full version. All parameters configurable.
23
24   Revision 1.9  2000/05/31 08:19:38  jbarbosa
25   Fixed bug in StepManager
26
27   Revision 1.8  2000/05/26 17:30:08  jbarbosa
28   Cerenkov angle now stored within cerenkov data structure.
29
30   Revision 1.7  2000/05/18 10:31:36  jbarbosa
31   Fixed positioning of spacers inside freon.
32   Fixed positioning of proximity gap
33   inside methane.
34   Fixed cut on neutral particles in the StepManager.
35
36   Revision 1.6  2000/04/28 11:51:58  morsch
37    Dimensions of arrays hits and Ckov_data corrected.
38
39   Revision 1.5  2000/04/19 13:28:46  morsch
40   Major changes in geometry (parametrised), materials (updated) and
41   step manager (diagnostics) (JB, AM)
42
43 */
44
45
46
47 //////////////////////////////////////////////////////////
48 //  Manager and hits classes for set: RICH full version //
49 //////////////////////////////////////////////////////////
50
51 #include <TTUBE.h>
52 #include <TNode.h> 
53 #include <TRandom.h> 
54 #include <TParticle.h> 
55
56 #include "AliRICHv1.h"
57 #include "AliRICHHit.h"
58 #include "AliRun.h"
59 #include "AliMC.h"
60 #include "iostream.h"
61 #include "AliCallf77.h"
62 #include "AliConst.h" 
63 #include "AliPDG.h" 
64 #include "TGeant3.h"
65
66 ClassImp(AliRICHv1)
67     
68 //___________________________________________
69 AliRICHv1::AliRICHv1() : AliRICHv0()
70 {
71
72 // Default constructor fo AliRICHvv1 (full version)
73
74     //fChambers = 0;
75 }
76
77 //___________________________________________
78 AliRICHv1::AliRICHv1(const char *name, const char *title)
79     : AliRICHv0(name,title)
80 {
81
82 // Full version of RICH with hits and diagnostics
83
84     fCkovNumber=0;
85     fFreonProd=0;
86     Int_t i=0;
87
88     fChambers = new TObjArray(kNCH);
89     for (i=0; i<kNCH; i++) {
90     
91         (*fChambers)[i] = new AliRICHChamber();  
92         
93     }
94 }
95
96 void AliRICHv1::Init()
97 {
98
99   printf("*********************************** RICH_INIT ***********************************\n");
100   printf("*                                                                               *\n");
101   printf("*                    AliRICHv1 Configurable version started                     *\n");
102   printf("*                                                                               *\n");
103
104   
105   AliRICHSegmentation*  segmentation;
106   AliRICHGeometry*  geometry;
107   AliRICHResponse*  response;
108
109
110     // 
111     // Initialize Tracking Chambers
112     //
113     for (i=1; i<kNCH; i++) {
114         //printf ("i:%d",i);
115         ( (AliRICHChamber*) (*fChambers)[i])->Init();  
116     }  
117     
118     //
119     // Set the chamber (sensitive region) GEANT identifier
120     
121     ((AliRICHChamber*)(*fChambers)[0])->SetGid(1);  
122     ((AliRICHChamber*)(*fChambers)[1])->SetGid(2);  
123     ((AliRICHChamber*)(*fChambers)[2])->SetGid(3);  
124     ((AliRICHChamber*)(*fChambers)[3])->SetGid(4);  
125     ((AliRICHChamber*)(*fChambers)[4])->SetGid(5);  
126     ((AliRICHChamber*)(*fChambers)[5])->SetGid(6);  
127     ((AliRICHChamber*)(*fChambers)[6])->SetGid(7); 
128
129     Float_t pos1[3]={0,471.8999,165.2599};
130     Chamber(0).SetChamberTransform(pos1[0],pos1[1],pos1[2],new TRotMatrix("rot993","rot993",90,0,70.69,90,19.30999,-90));
131
132     Float_t pos2[3]={171,470,0};
133     Chamber(1).SetChamberTransform(pos2[0],pos2[1],pos2[2],new TRotMatrix("rot994","rot994",90,-20,90,70,0,0));
134
135     Float_t pos3[3]={0,500,0};
136     Chamber(2).SetChamberTransform(pos3[0],pos3[1],pos3[2],new TRotMatrix("rot995","rot995",90,0,90,90,0,0));
137     
138     Float_t pos4[3]={-171,470,0};
139     Chamber(3).SetChamberTransform(pos4[0],pos4[1],pos4[2], new TRotMatrix("rot996","rot996",90,20,90,110,0,0));  
140
141     Float_t pos5[3]={161.3999,443.3999,-165.3};
142     Chamber(4).SetChamberTransform(pos5[0],pos5[1],pos5[2],new TRotMatrix("rot997","rot997",90,340,108.1999,70,18.2,70));
143
144     Float_t pos6[3]={0., 471.9, -165.3,};
145     Chamber(5).SetChamberTransform(pos6[0],pos6[1],pos6[2],new TRotMatrix("rot998","rot998",90,0,109.3099,90,19.30999,90));
146
147     Float_t pos7[3]={-161.399,443.3999,-165.3};
148     Chamber(6).SetChamberTransform(pos7[0],pos7[1],pos7[2],new TRotMatrix("rot999","rot999",90,20,108.1999,110,18.2,110));
149     
150     segmentation=Chamber(0).GetSegmentationModel(0);
151     geometry=Chamber(0).GetGeometryModel();
152     response=Chamber(0).GetResponseModel();
153     
154      
155     printf("*                            Pads            : %3dx%3d                          *\n",segmentation->Npx(),segmentation->Npy());
156     printf("*                            Pad size        : %5.2f x%5.2f mm2                 *\n",segmentation->Dpx(),segmentation->Dpy()); 
157     printf("*                            Gap Thickness   : %5.1f mm                         *\n",geometry->GetGapThickness());
158     printf("*                            Radiator Width  : %5.1f mm                         *\n",geometry->GetQuartzWidth());
159     printf("*                            Radiator Length : %5.1f mm                         *\n",geometry->GetQuartzLength());
160     printf("*                            Freon Thickness : %5.1f mm                         *\n",geometry->GetFreonThickness());
161     printf("*                            Charge Slope    : %5.1f ADC                        *\n",response->ChargeSlope());
162     printf("*                            Feedback Prob.  : %5.2f %%                          *\n",response->AlphaFeedback());
163     printf("*                                                                               *\n");
164     printf("*                                   Success!                                    *\n");
165     printf("*                                                                               *\n");
166     printf("*********************************************************************************\n");
167
168 }
169
170 //___________________________________________
171 void AliRICHv1::StepManager()
172 {
173
174 // Full Step Manager
175
176     Int_t          copy, id;
177     static Int_t   idvol;
178     static Int_t   vol[2];
179     Int_t          ipart;
180     static Float_t hits[18];
181     static Float_t ckovData[19];
182     TLorentzVector position;
183     TLorentzVector momentum;
184     Float_t        pos[3];
185     Float_t        mom[4];
186     Float_t        localPos[3];
187     Float_t        localMom[4];
188     Float_t        localTheta,localPhi;
189     Float_t        theta,phi;
190     Float_t        destep, step;
191     Float_t        ranf[2];
192     Int_t          nPads;
193     Float_t        coscerenkov;
194     static Float_t eloss, xhit, yhit, tlength;
195     const  Float_t kBig=1.e10;
196        
197     TClonesArray &lhits = *fHits;
198     TGeant3 *geant3 = (TGeant3*) gMC;
199     TParticle *current = (TParticle*)(*gAlice->Particles())[gAlice->CurrentTrack()];
200
201  //if (current->Energy()>1)
202    //{
203         
204     // Only gas gap inside chamber
205     // Tag chambers and record hits when track enters 
206     
207     idvol=-1;
208     id=gMC->CurrentVolID(copy);
209     Float_t cherenkovLoss=0;
210     //gAlice->KeepTrack(gAlice->CurrentTrack());
211     
212     gMC->TrackPosition(position);
213     pos[0]=position(0);
214     pos[1]=position(1);
215     pos[2]=position(2);
216     ckovData[1] = pos[0];                 // X-position for hit
217     ckovData[2] = pos[1];                 // Y-position for hit
218     ckovData[3] = pos[2];                 // Z-position for hit
219     //ckovData[11] = gAlice->CurrentTrack();
220
221     //AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH"); 
222     
223     /********************Store production parameters for Cerenkov photons************************/ 
224 //is it a Cerenkov photon? 
225     if (gMC->TrackPid() == 50000050) {          
226
227       //if (gMC->VolId("GAP ")==gMC->CurrentVolID(copy))
228         //{                    
229           Float_t ckovEnergy = current->Energy();
230           //energy interval for tracking
231           if  (ckovEnergy > 5.6e-09 && ckovEnergy < 7.8e-09 )       
232             //if (ckovEnergy > 0)
233             {
234               if (gMC->IsTrackEntering()){                                     //is track entering?
235                 if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
236                   {                                                          //is it in freo?
237                     if (geant3->Gctrak()->nstep<1){                          //is it the first step?
238                       Int_t mother = current->GetFirstMother(); 
239                       
240                       //printf("Second Mother:%d\n",current->GetSecondMother());
241                       
242                       ckovData[10] = mother;
243                       ckovData[11] = gAlice->CurrentTrack();
244                       ckovData[12] = 1;             //Media where photon was produced 1->Freon, 2->Quarz
245                       fCkovNumber++;
246                       fFreonProd=1;
247                       //printf("Index: %d\n",fCkovNumber);
248                     }    //first step question
249                   }        //freo question
250                 
251                 if (geant3->Gctrak()->nstep<1){                                  //is it first step?
252                   if (gMC->VolId("QUAR")==gMC->CurrentVolID(copy))             //is it in quarz?
253                     {
254                       ckovData[12] = 2;
255                     }    //quarz question
256                 }        //first step question
257                 
258                 //printf("Before %d\n",fFreonProd);
259               }   //track entering question
260               
261               if (ckovData[12] == 1)                                        //was it produced in Freon?
262                 //if (fFreonProd == 1)
263                 {
264                   if (gMC->IsTrackEntering()){                                     //is track entering?
265                     //printf("Got in");
266                     if (gMC->VolId("META")==gMC->CurrentVolID(copy))                //is it in gap?      
267                       {
268                         //printf("Got in\n");
269                         gMC->TrackMomentum(momentum);
270                         mom[0]=momentum(0);
271                         mom[1]=momentum(1);
272                         mom[2]=momentum(2);
273                         mom[3]=momentum(3);
274                         // Z-position for hit
275                         
276                         
277                         /**************** Photons lost in second grid have to be calculated by hand************/ 
278                         
279                         Float_t cophi = TMath::Cos(TMath::ATan2(mom[0], mom[1]));
280                         Float_t t = (1. - .025 / cophi) * (1. - .05 /  cophi);
281                         gMC->Rndm(ranf, 1);
282                         //printf("grid calculation:%f\n",t);
283                         if (ranf[0] > t) {
284                           //geant3->StopTrack();
285                           ckovData[13] = 5;
286                           AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
287                           //printf("Lost one in grid\n");
288                         }
289                         /**********************************************************************************/
290                       }    //gap
291                     
292                     if (gMC->VolId("CSI ")==gMC->CurrentVolID(copy))             //is it in csi?      
293                       {
294                         gMC->TrackMomentum(momentum);
295                         mom[0]=momentum(0);
296                         mom[1]=momentum(1);
297                         mom[2]=momentum(2);
298                         mom[3]=momentum(3);
299                         
300                         /********* Photons lost by Fresnel reflection have to be calculated by hand********/ 
301                         /***********************Cerenkov phtons (always polarised)*************************/
302                         
303                         Float_t cophi = TMath::Cos(TMath::ATan2(mom[0], mom[1]));
304                         Float_t t = Fresnel(ckovEnergy*1e9,cophi,1);
305                         gMC->Rndm(ranf, 1);
306                         if (ranf[0] < t) {
307                           //geant3->StopTrack();
308                           ckovData[13] = 6;
309                           AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
310                           //printf("Lost by Fresnel\n");
311                         }
312                         /**********************************************************************************/
313                       }
314                   } //track entering?
315                   
316                   
317                   /********************Evaluation of losses************************/
318                   /******************still in the old fashion**********************/
319                   
320                   Int_t i1 = geant3->Gctrak()->nmec;            //number of physics mechanisms acting on the particle
321                   for (Int_t i = 0; i < i1; ++i) {
322                     //        Reflection loss 
323                     if (geant3->Gctrak()->lmec[i] == 106) {        //was it reflected
324                       ckovData[13]=10;
325                       if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy)) 
326                         ckovData[13]=1;
327                       if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR")) 
328                         ckovData[13]=2;
329                       //geant3->StopTrack();
330                       AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
331                     } //reflection question
332                     
333                     
334                     //        Absorption loss 
335                     else if (geant3->Gctrak()->lmec[i] == 101) {              //was it absorbed?
336                       ckovData[13]=20;
337                       if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy)) 
338                         ckovData[13]=11;
339                       if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR")) 
340                         ckovData[13]=12;
341                       if (gMC->CurrentVolID(copy) == gMC->VolId("META")) 
342                         ckovData[13]=13;
343                       if (gMC->CurrentVolID(copy) == gMC->VolId("GAP ")) 
344                         ckovData[13]=13;
345                       
346                       if (gMC->CurrentVolID(copy) == gMC->VolId("SRIC")) 
347                         ckovData[13]=15;
348                       
349                       //        CsI inefficiency 
350                       if (gMC->CurrentVolID(copy) == gMC->VolId("CSI ")) {
351                         ckovData[13]=16;
352                       }
353                       //geant3->StopTrack();
354                       AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
355                       //printf("Added cerenkov %d\n",fCkovNumber);
356                     } //absorption question 
357                     
358                     
359                     //        Photon goes out of tracking scope 
360                     else if (geant3->Gctrak()->lmec[i] == 30) {                 //is it below energy treshold?
361                       ckovData[13]=21;
362                       //geant3->StopTrack();
363                       AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
364                     }   // energy treshold question         
365                   }  //number of mechanisms cycle
366                   /**********************End of evaluation************************/
367                 } //freon production question
368             } //energy interval question
369         //}//inside the proximity gap question
370     } //cerenkov photon question
371       
372     /**************************************End of Production Parameters Storing*********************/ 
373     
374     
375     /*******************************Treat photons that hit the CsI (Ckovs and Feedbacks)************/ 
376     
377     if (gMC->TrackPid() == 50000050 || gMC->TrackPid() == 50000051) {
378       //printf("Cerenkov\n");
379         if (gMC->VolId("CSI ")==gMC->CurrentVolID(copy))
380         {
381             
382           if (gMC->Edep() > 0.){
383                 gMC->TrackPosition(position);
384                 gMC->TrackMomentum(momentum);
385                 pos[0]=position(0);
386                 pos[1]=position(1);
387                 pos[2]=position(2);
388                 mom[0]=momentum(0);
389                 mom[1]=momentum(1);
390                 mom[2]=momentum(2);
391                 mom[3]=momentum(3);
392                 Double_t tc = mom[0]*mom[0]+mom[1]*mom[1];
393                 Double_t rt = TMath::Sqrt(tc);
394                 theta   = Float_t(TMath::ATan2(rt,Double_t(mom[2])))*kRaddeg;
395                 phi     = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
396                 gMC->Gmtod(pos,localPos,1);                                                                    
397                 gMC->Gmtod(mom,localMom,2);
398                 
399                 gMC->CurrentVolOffID(2,copy);
400                 vol[0]=copy;
401                 idvol=vol[0]-1;
402
403                 //Int_t sector=((AliRICHChamber*) (*fChambers)[idvol])
404                         //->Sector(localPos[0], localPos[2]);
405                 //printf("Sector:%d\n",sector);
406
407                 /*if (gMC->TrackPid() == 50000051){
408                   fFeedbacks++;
409                   printf("Feedbacks:%d\n",fFeedbacks);
410                 }*/     
411                 
412                 ((AliRICHChamber*) (*fChambers)[idvol])
413                     ->SigGenInit(localPos[0], localPos[2], localPos[1]);
414                 if(idvol<kNCH) {        
415                     ckovData[0] = gMC->TrackPid();        // particle type
416                     ckovData[1] = pos[0];                 // X-position for hit
417                     ckovData[2] = pos[1];                 // Y-position for hit
418                     ckovData[3] = pos[2];                 // Z-position for hit
419                     ckovData[4] = theta;                      // theta angle of incidence
420                     ckovData[5] = phi;                      // phi angle of incidence 
421                     ckovData[8] = (Float_t) fNPadHits;      // first padhit
422                     ckovData[9] = -1;                       // last pad hit
423                     ckovData[13] = 4;                       // photon was detected
424                     ckovData[14] = mom[0];
425                     ckovData[15] = mom[1];
426                     ckovData[16] = mom[2];
427                     
428                     destep = gMC->Edep();
429                     gMC->SetMaxStep(kBig);
430                     cherenkovLoss  += destep;
431                     ckovData[7]=cherenkovLoss;
432                     
433                     nPads = MakePadHits(localPos[0],localPos[2],cherenkovLoss,idvol,kCerenkov);
434                     if (fNPadHits > (Int_t)ckovData[8]) {
435                         ckovData[8]= ckovData[8]+1;
436                         ckovData[9]= (Float_t) fNPadHits;
437                     }
438
439                     ckovData[17] = nPads;
440                     //printf("nPads:%d",nPads);
441                     
442                     //TClonesArray *Hits = RICH->Hits();
443                     AliRICHHit *mipHit =  (AliRICHHit*) (fHits->UncheckedAt(0));
444                     if (mipHit)
445                       {
446                         mom[0] = current->Px();
447                         mom[1] = current->Py();
448                         mom[2] = current->Pz();
449                         Float_t mipPx = mipHit->fMomX;
450                         Float_t mipPy = mipHit->fMomY;
451                         Float_t mipPz = mipHit->fMomZ;
452                         
453                         Float_t r = mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2];
454                         Float_t rt = TMath::Sqrt(r);
455                         Float_t mipR = mipPx*mipPx + mipPy*mipPy + mipPz*mipPz; 
456                         Float_t mipRt = TMath::Sqrt(mipR);
457                         if ((rt*mipRt) > 0)
458                           {
459                             coscerenkov = (mom[0]*mipPx + mom[1]*mipPy + mom[2]*mipPz)/(rt*mipRt);
460                           }
461                         else
462                           {
463                             coscerenkov = 0;
464                           }
465                         Float_t cherenkov = TMath::ACos(coscerenkov);
466                         ckovData[18]=cherenkov;
467                       }
468                     //if (sector != -1)
469                     //{
470                     AddHit(gAlice->CurrentTrack(),vol,ckovData);
471                     AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
472                     //}
473                 }
474             }
475         }
476     }
477     
478     /***********************************************End of photon hits*********************************************/
479     
480
481     /**********************************************Charged particles treatment*************************************/
482
483     else if (gMC->TrackCharge())
484     //else if (1 == 1)
485       {
486 //If MIP
487         /*if (gMC->IsTrackEntering())
488           {                
489             hits[13]=20;//is track entering?
490           }*/
491         if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
492           {
493             fFreonProd=1;
494           }
495
496         if (gMC->VolId("GAP ")== gMC->CurrentVolID(copy)) {
497 // Get current particle id (ipart), track position (pos)  and momentum (mom)
498             
499             gMC->CurrentVolOffID(3,copy);
500             vol[0]=copy;
501             idvol=vol[0]-1;
502
503             //Int_t sector=((AliRICHChamber*) (*fChambers)[idvol])
504                         //->Sector(localPos[0], localPos[2]);
505             //printf("Sector:%d\n",sector);
506             
507             gMC->TrackPosition(position);
508             gMC->TrackMomentum(momentum);
509             pos[0]=position(0);
510             pos[1]=position(1);
511             pos[2]=position(2);
512             mom[0]=momentum(0);
513             mom[1]=momentum(1);
514             mom[2]=momentum(2);
515             mom[3]=momentum(3);
516             gMC->Gmtod(pos,localPos,1);                                                                    
517             gMC->Gmtod(mom,localMom,2);
518             
519             ipart  = gMC->TrackPid();
520             //
521             // momentum loss and steplength in last step
522             destep = gMC->Edep();
523             step   = gMC->TrackStep();
524   
525             //
526             // record hits when track enters ...
527             if( gMC->IsTrackEntering()) {
528 //              gMC->SetMaxStep(fMaxStepGas);
529                 Double_t tc = mom[0]*mom[0]+mom[1]*mom[1];
530                 Double_t rt = TMath::Sqrt(tc);
531                 theta   = Float_t(TMath::ATan2(rt,Double_t(mom[2])))*kRaddeg;
532                 phi     = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
533                 
534
535                 Double_t localTc = localMom[0]*localMom[0]+localMom[2]*localMom[2];
536                 Double_t localRt = TMath::Sqrt(localTc);
537                 localTheta   = Float_t(TMath::ATan2(localRt,Double_t(localMom[1])))*kRaddeg;                       
538                 localPhi     = Float_t(TMath::ATan2(Double_t(localMom[2]),Double_t(localMom[0])))*kRaddeg;    
539                 
540                 hits[0] = Float_t(ipart);         // particle type
541                 hits[1] = localPos[0];                 // X-position for hit
542                 hits[2] = localPos[1];                 // Y-position for hit
543                 hits[3] = localPos[2];                 // Z-position for hit
544                 hits[4] = localTheta;                  // theta angle of incidence
545                 hits[5] = localPhi;                    // phi angle of incidence 
546                 hits[8] = (Float_t) fNPadHits;    // first padhit
547                 hits[9] = -1;                     // last pad hit
548                 hits[13] = fFreonProd;           // did id hit the freon?
549                 hits[14] = mom[0];
550                 hits[15] = mom[1];
551                 hits[16] = mom[2];
552
553                 tlength = 0;
554                 eloss   = 0;
555                 fFreonProd = 0;
556         
557                 Chamber(idvol).LocaltoGlobal(localPos,hits+1);
558            
559                 
560                 //To make chamber coordinates x-y had to pass localPos[0], localPos[2]
561                 xhit    = localPos[0];
562                 yhit    = localPos[2];
563                 // Only if not trigger chamber
564                 if(idvol<kNCH) {
565                     //
566                     //  Initialize hit position (cursor) in the segmentation model 
567                     ((AliRICHChamber*) (*fChambers)[idvol])
568                         ->SigGenInit(localPos[0], localPos[2], localPos[1]);
569                 }
570             }
571             
572             // 
573             // Calculate the charge induced on a pad (disintegration) in case 
574             //
575             // Mip left chamber ...
576             if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
577                 gMC->SetMaxStep(kBig);
578                 eloss   += destep;
579                 tlength += step;
580                 
581                                 
582                 // Only if not trigger chamber
583                 if(idvol<kNCH) {
584                   if (eloss > 0) 
585                     {
586                       if(gMC->TrackPid() == kNeutron)
587                         printf("\n\n\n\n\n Neutron Making Pad Hit!!! \n\n\n\n");
588                       nPads = MakePadHits(xhit,yhit,eloss,idvol,kMip);
589                       hits[17] = nPads;
590                       //printf("nPads:%d",nPads);
591                     }
592                 }
593                 
594                 hits[6]=tlength;
595                 hits[7]=eloss;
596                 if (fNPadHits > (Int_t)hits[8]) {
597                     hits[8]= hits[8]+1;
598                     hits[9]= (Float_t) fNPadHits;
599                 }
600                 
601                 //if(sector !=-1)
602                 new(lhits[fNhits++]) AliRICHHit(fIshunt,gAlice->CurrentTrack(),vol,hits);
603                 eloss = 0; 
604                 //
605                 // Check additional signal generation conditions 
606                 // defined by the segmentation
607                 // model (boundary crossing conditions) 
608             } else if 
609                 (((AliRICHChamber*) (*fChambers)[idvol])
610                  ->SigGenCond(localPos[0], localPos[2], localPos[1]))
611             {
612                 ((AliRICHChamber*) (*fChambers)[idvol])
613                     ->SigGenInit(localPos[0], localPos[2], localPos[1]);
614                 if (eloss > 0) 
615                   {
616                     if(gMC->TrackPid() == kNeutron)
617                       printf("\n\n\n\n\n Neutron Making Pad Hit!!! \n\n\n\n");
618                     nPads = MakePadHits(xhit,yhit,eloss,idvol,kMip);
619                     hits[17] = nPads;
620                     //printf("Npads:%d",NPads);
621                   }
622                 xhit     = localPos[0];
623                 yhit     = localPos[2]; 
624                 eloss    = destep;
625                 tlength += step ;
626                 //
627                 // nothing special  happened, add up energy loss
628             } else {        
629                 eloss   += destep;
630                 tlength += step ;
631             }
632         }
633       }
634     /*************************************************End of MIP treatment**************************************/
635    //}
636 }