New ITS code for new structure and simulations.
[u/mrichter/AliRoot.git] / ITS / AliITSpackageSSD.cxx
1 #include "AliITSpackageSSD.h"
2 //************************************************
3 //Piotr Krzysztof Skowronski
4 //Warsaw University of Technology
5 //skowron@if.pw.edu.pl
6 //
7
8 const Int_t debug=0;
9
10 ClassImp(AliITSpackageSSD)
11
12 AliITSpackageSSD::AliITSpackageSSD()
13 {
14   fNclustersN=0;
15   fClusterNIndexes = new TArrayI(300); 
16                 
17   fNclustersP=0;
18   fClusterPIndexes = new TArrayI(300);
19   if (debug) cout<<"Default Ctor was used\n>>>>>>>>>>>>>><<<<<<<<<<<<<";
20 }
21
22
23 /*******************************************************/
24
25 AliITSpackageSSD::AliITSpackageSSD
26   (TClonesArray *clustersP, TClonesArray *clustersN)
27 {
28   fClustersP=clustersP;
29   fClustersN=clustersN;
30         
31   fNclustersN=0;
32   fClusterNIndexes = new TArrayI(300); 
33         
34   fNclustersP=0;
35   fClusterPIndexes = new TArrayI(300);          
36 }
37
38 /*******************************************************/
39
40
41 AliITSpackageSSD::AliITSpackageSSD
42   ( Int_t len, TClonesArray *clustersP, TClonesArray *clustersN)
43
44 {       
45   fClustersP=clustersP;
46   fClustersN=clustersN;
47
48   fNclustersN=0;
49   fClusterNIndexes = new TArrayI(len); 
50         
51   fNclustersP=0;
52   fClusterPIndexes = new TArrayI(len);          
53 }
54
55
56 /*******************************************************/
57
58 AliITSpackageSSD::~AliITSpackageSSD()
59 {
60   // destructor
61   delete fClusterNIndexes;
62   delete fClusterPIndexes;              
63 }
64 /*******************************************************/
65
66 AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
67 {
68   // copy constractor
69   Int_t i;  //iterator
70  
71   if (this == &package) return;
72   fClustersN = package.fClustersN;
73   fClustersP = package.fClustersP;
74   
75   fNclustersN= package.fNclustersN;
76   fNclustersP= package.fNclustersP;
77   
78   for(i =0; i<fNclustersN;i++)
79     {
80       fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
81     }
82   
83   for(i =0; i<fNclustersP;i++)
84     {
85       fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
86     }
87   
88   if (debug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
89   
90   return; 
91   
92 }
93 /*******************************************************/
94
95 AliITSpackageSSD&  
96 AliITSpackageSSD::operator=( const AliITSpackageSSD & package)
97 {
98
99 Int_t i;  //iterator
100  
101 if (this == &package) return *this;
102 fClustersN = package.fClustersN;
103 fClustersP = package.fClustersP;
104
105 fNclustersN= package.fNclustersN;
106 fNclustersP= package.fNclustersP;
107
108 for(i =0; i<fNclustersN;i++)
109   {
110     fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
111   }
112
113 for(i =0; i<fNclustersP;i++)
114   {
115     fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
116   }
117
118 if (debug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
119
120 return *this; 
121   
122 }
123
124
125 /*******************************************************/
126
127 Int_t 
128 AliITSpackageSSD::GetNSideClusterIdx(Int_t index)
129
130 {
131   if ((index>-1)&&(index<fNclustersN))
132     return (*fClusterNIndexes)[index];
133   else 
134    {
135     cout << "AliITSpackageSSD::GetNSideClusterIdx  : Out of Range\n";
136     return -1;
137    }
138 }
139 /*******************************************************/
140
141
142 Int_t AliITSpackageSSD::GetPSideClusterIdx(Int_t index)
143 {
144   if ((index>-1)&&(index<fNclustersP))
145     return (*fClusterPIndexes)[index];
146   else 
147   {
148   cout << "AliITSpackageSSD::GetPSideClusterIdx  : Out of Range\n";
149    return -1;
150   } 
151 }
152 /*******************************************************/
153 AliITSclusterSSD*  
154 AliITSpackageSSD::GetPSideCluster(Int_t index)
155 {
156
157 return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
158 }
159
160 /*******************************************************/
161
162 AliITSclusterSSD*  
163 AliITSpackageSSD::GetNSideCluster(Int_t index)
164 {
165 return (AliITSclusterSSD*)((*fClustersN)[GetNSideClusterIdx(index)]);
166 }
167
168
169 /*******************************************************/
170
171
172
173 Bool_t 
174 AliITSpackageSSD::GetClusterWithOneCross
175   (Int_t & index, Bool_t& side)
176 {
177   
178  
179  if((fNclustersP==0)||(fNclustersN==0) )
180   {
181     printf("Empty package ((fNclustersP==0)||(fNclustersN==0))\n");
182     index = -2;
183     return kFALSE;
184   } 
185  Int_t ind;
186
187  ind =(*fClusterPIndexes)[fNclustersP-1]; 
188  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo()  ) ==1 )
189   {
190     //index=ind;
191     index =fNclustersP-1; 
192     side=SIDEP;
193     return kTRUE;
194   }
195  
196  ind =(*fClusterNIndexes)[fNclustersN-1]; 
197  if (  (  ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo() ) ==1  )
198   {
199     //index=ind;
200     index = fNclustersN-1;
201     side=SIDEN;
202     return kTRUE;
203   }
204   
205
206  ind =(*fClusterPIndexes)[0];
207  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo() ) ==1 )
208   {
209     //index=ind;
210     index = 0;
211     side=SIDEP;
212     return kTRUE;
213   }
214   
215
216  ind =(*fClusterNIndexes)[0];
217  if (  ( ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo()  ) ==1  )
218   {
219 //    index=ind;
220     index = 0;  
221     side=SIDEN;
222     return kTRUE;
223   }
224   
225   
226  //Add for to be shure 
227  index = -1;
228  return kFALSE;
229   
230 }
231 /*******************************************************/
232
233 void AliITSpackageSSD::DelCluster(Int_t index, Bool_t side)
234 {
235   if(side==SIDEP) DelPCluster(index); else DelNCluster(index);
236 }
237 /*******************************************************/
238 void AliITSpackageSSD::DelPCluster(Int_t index)
239 {
240
241 //it not deletes delete given cluster physically, 
242 //but only complytely erase it from package
243 //all clusters are deleted automatically when TClonesArray is deleted
244
245   Int_t i;
246   Int_t idx;
247   Int_t clToDelIdx = GetPSideClusterIdx(index); //Index of cluster in TClonesArray 
248   AliITSclusterSSD *clToDel = GetPSideCluster(index); //cluster to be deleted
249   Int_t ncr = clToDel->GetCrossNo();
250   
251   for(i =0;i<ncr;i++)
252    {
253     idx = clToDel->GetCross(i);
254     ((AliITSclusterSSD *)((*fClustersN)[idx])   )->DelCross(clToDelIdx);
255    }
256  
257  
258  for(i=index;i<fNclustersP-1;i++)
259   {
260        (*fClusterPIndexes)[i]=(*fClusterPIndexes)[i+1];
261   }
262  fNclustersP--; 
263  if (debug) cout<<"Cluster P ("<<index<<") deleted\n";
264
265
266  for(i=0;i<fNclustersN;i++)
267   {
268     if ( (GetNSideCluster(i)->GetCrossNo())==0) DelNCluster(i);
269   }
270 }
271
272
273
274 /*******************************************************/
275 void AliITSpackageSSD::DelNCluster(Int_t index)
276 {
277
278 //it not deletes delete given cluster physically, 
279 //but only complytely erase it from package
280 //all clusters are deleted automatically when TClonesArray is deleted
281
282   Int_t i;
283   Int_t idx;
284   Int_t clToDelIdx = GetNSideClusterIdx(index); //Index of cluster in TClonesArray 
285   AliITSclusterSSD *clToDel = GetNSideCluster(index); //cluster to be deleted
286   Int_t ncr = clToDel->GetCrossNo();
287   
288   for(i =0;i<ncr;i++)
289    {
290     idx = clToDel->GetCross(i);
291     ((AliITSclusterSSD *)((*fClustersP)[idx])   )->DelCross(clToDelIdx);
292    }
293  
294  
295  for(i=index;i<fNclustersN-1;i++)
296   {
297        (*fClusterNIndexes)[i]=(*fClusterNIndexes)[i+1];
298   }
299  fNclustersN--; 
300  if (debug) cout<<"Cluster N ("<<index<<") deleted\n";
301
302  for(i=0;i<fNclustersP;i++)
303   {
304     if ( (GetPSideCluster(i)->GetCrossNo())==0) DelPCluster(i);
305   }
306
307 }
308
309
310 /*******************************************************/
311
312 void AliITSpackageSSD::DelPClusterOI(Int_t index)
313 {
314 //This function looks like this, 
315 //because probably cut cluster is 
316 //on the beginning or on the end of package 
317  Int_t i;
318  if( ((*fClusterPIndexes)[0]) == index) 
319   {
320     DelPCluster(0);
321     return;
322   }
323  else
324   { 
325    if( ((*fClusterPIndexes)[fNclustersP-1]) ==index)
326     {
327       DelPCluster(fNclustersP-1);
328       return;
329     }
330    else
331     {
332      for(i=1;i<fNclustersP-1;i++)
333        {
334          if( ((*fClusterPIndexes)[i])==index)
335           {
336             DelPCluster(i);
337             return;
338           }
339        }
340     }
341   }
342  
343  cout<<"AliITSpackageSSD - DelPClusterOI: index "<<index<<" not found\n";
344
345 }
346
347
348 /*******************************************************/
349
350 void AliITSpackageSSD::DelNClusterOI(Int_t index)
351 {
352 //This function looks like this, 
353 //because probably cluster to cut is 
354 //on the beginning or on the end of package 
355
356  Int_t i;
357  if( ((*fClusterNIndexes)[0])==index) 
358   {
359     DelNCluster(0);
360     return;
361   }
362  else
363   { 
364    if( ((*fClusterNIndexes)[fNclustersN-1])==index)
365     {
366       DelNCluster(fNclustersN-1);
367       return;
368     }
369    else
370     {
371      for(i=1;i<fNclustersN-1;i++)
372        {
373          if( ((*fClusterNIndexes)[i])==index)
374          {
375           DelNCluster(i);
376           return;
377          }
378        }
379     }
380   }
381  cout<<"AliITSpackageSSD - DelNClusterOI: index "<<index<<" not found\n";
382 }
383
384
385 /*******************************************************/
386
387
388 void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
389 {
390  if (side == SIDEP)
391   {    
392     DelPClusterOI(index);
393   } 
394   else
395   {
396     DelNClusterOI(index);
397   }
398
399 }
400
401
402 /**********************************************/
403
404
405 void  AliITSpackageSSD::GetAllCombinations(Int_t**array,Int_t &num,Int_t sizet)
406 {
407   
408   Int_t *takenNcl = new Int_t[fNclustersN];
409   
410   num=0;
411   
412   if (debug) PrintClusters();
413
414   Int_t i;
415   for(i=0;i<fNclustersP;i++)
416    {
417      takenNcl[i]=-1;
418    }
419   //see comment on the beginning of MakeCombin
420   if (debug) cout<<"GetAllCombinations entered";
421   MakeCombin (array,num,0,takenNcl,sizet);
422
423   delete []takenNcl; 
424 }
425 /**********************************************/
426
427
428 void  AliITSpackageSSD::MakeCombin
429    (Int_t**arr,Int_t& nu, Int_t np, Int_t *occup, Int_t sizet)
430
431 {
432
433 //ATTENTION: anybody watching this function
434 //AliITSclusterSSD::GetCrossNo() returns index of cluster in main array belonging to AliITSmodulesSSD
435 //however, we have pointer to that array (TClonesArray)
436 //we can not use 
437 //Get?SideCluster because it takes index from local look_up_table
438  
439  Int_t i,j;
440  
441  //this cluster
442  AliITSclusterSSD *cl=GetPSideCluster(np);
443
444  //printf("np %d cl %p\n",np,cl);
445
446  
447  Int_t NC = cl->GetCrossNo();  //number of crosses for this cluster
448  Int_t indcro;                 //index of given cluster on side N that 
449                                // this cluster crosses with
450    
451  // printf("NC %d \n",NC);
452
453
454  if (np == fNclustersP-1) {
455    //printf("if \n");
456    for(i=0;i<NC;i++) {
457      indcro=cl->GetCross(i);
458      //printf("if: i indcro %d %d\n",i, indcro);
459      if(IsFree(indcro,np,occup)) {
460         occup[np]=indcro;
461         //printf("if- isFree: i np occup[np] %d %d %d\n",i,np,occup[np]);
462         for(j=0;j<fNclustersP;j++)  
463         {
464           //printf("if- for: j nu occup[j] %d %d %d\n",j, nu, occup[j]);
465            if (nu<sizet) arr[nu][j]=occup[j];
466            else {
467              //printf("MakeComb - exceeding array size! i j %d %d\n",i,j);
468                continue;}
469            //printf("if- for: j nu arr[nu][j] %d %d %d\n",j, nu, arr[nu][j]);
470            
471         }
472       
473         occup[np]=-1;
474         if (nu<sizet-1) nu++;
475         //printf("i j nu %d %d %d \n",i,j,nu);
476      }
477    }
478   } else {
479     // printf("else \n");
480
481     for(i=0;i<NC;i++) {
482        indcro=cl->GetCross(i);
483        //printf("else: i indcro %d %d\n",i, indcro);
484        if(IsFree(indcro,np,occup)) {
485           occup[np]=indcro;
486           //printf("else:recursive call - i np occup %d %d %d\n",i,np,occup[np]);
487           if (nu<sizet) MakeCombin(arr,nu,(np+1),occup,sizet);
488           //else printf("MakeComb - exceeding array size!\n");
489        }
490     }
491     occup[np]=-1;
492   } 
493
494 }
495
496 /**********************************************/
497 Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, Int_t *lis)
498 {
499
500   Int_t i;
501   for(i=0;i<nn;i++)
502     {
503       if (lis[i]==idx) return kFALSE;
504     }
505   return kTRUE;
506 }
507
508 /**********************************************/
509 void AliITSpackageSSD::PrintClusters()
510 {
511
512 Int_t i,j;
513 cout<<"SIDE P\n";
514 for(i=0;i<fNclustersP;i++)
515  {
516    cout<<i<<".  IO="<<GetPSideClusterIdx(i)<<" NC="<<GetPSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
517    for(j=0;j<GetPSideCluster(i)->GetCrossNo();j++)
518     {
519       cout<<GetPSideCluster(i)->GetCross(j)<<" ";
520     }
521  //  if (GetPSideCluster(i)->GetSide()) cout<<" P\n";
522  //  else cout<<"BAD SIDE ==N\n";
523     cout<<"\n";
524    
525  }
526
527 cout <<"SIDE N\n";
528 for(i=0;i<fNclustersN;i++)
529  {
530    cout<<i<<".  IO="<<GetNSideClusterIdx(i)<<" NC="<<GetNSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
531    for(j=0;j<GetNSideCluster(i)->GetCrossNo();j++)
532     {
533       cout<<GetNSideCluster(i)->GetCross(j)<<" ";
534     }
535  //  if (GetNSideCluster(i)->GetSide()) cout<<" N\n";
536  //  else cout<<"BAD SIDE ==P\n";
537     cout<<"\n";   
538  }
539  
540  
541  
542 }
543 /**********************************************/
544 void AliITSpackageSSD::ConsumeClusters()
545 {
546 register Int_t i;
547
548 for(i=0;i<fNclustersP;i++)
549  {
550    GetPSideCluster(i)->Consume();
551  }
552
553 for(i=0;i<fNclustersN;i++)
554  {
555    GetNSideCluster(i)->Consume();
556  }
557
558 }
559
560 /**********************************************/
561
562 Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI)
563 {
564  //Returns index of next P cluster OI in package; OI == Original Inedx (in TClonesArray)
565  //if not egsist return -1;
566  Int_t i;
567  for(i =0; i<fNclustersP-1;i++)
568   {
569     if(GetPSideClusterIdx(i) == OI)
570        return GetPSideClusterIdx(i+1);
571   }
572  return -1;
573 }
574 /**********************************************/
575 Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI)
576 {
577  //Returns index of previous P cluster  OI in package; OI == Original Inedx (in TClonesArray)
578  //if not egsist return -1;
579  
580  Int_t i;
581  for(i =1; i<fNclustersP;i++)
582   {
583     if(GetPSideClusterIdx(i) == OI)
584        return GetPSideClusterIdx(i-1);
585   }
586   return -1;
587 }
588 /**********************************************/
589 Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI)
590 {
591 //Returns index of next N cluster OI in package; OI == Original Inedx (in TClonesArray)
592  //if not egsist return -1;
593  Int_t i;
594  for(i =0; i<fNclustersN-1;i++)
595   {
596     if(GetNSideClusterIdx(i) == OI)
597        return GetNSideClusterIdx(i+1);
598   }
599  return -1;
600
601 }
602 /**********************************************/
603 Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI)
604 {
605  //Returns index of previous N cluster OI in package; OI == Original Inedx (in TClonesArray)
606  //if not egsist return -1;
607  
608  Int_t i;
609  for(i =1; i<fNclustersN;i++)
610   {
611     if(GetNSideClusterIdx(i) == OI)
612        return GetNSideClusterIdx(i-1);
613   }
614   return -1;
615  
616 }
617
618 void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
619 {
620   // split package of clusters
621   Int_t p=-1, n=-1;
622   Int_t i;
623   for(i=0;i<fNclustersN;i++)
624    {
625      if((*fClusterNIndexes)[i]==ni) 
626       {
627         n = i;
628         break;
629       }
630     } 
631    
632   for(i=0;i<fNclustersP;i++)
633    {
634      if((*fClusterPIndexes)[i]==pi) 
635       {
636         p = i;
637         break;
638       }
639     }  
640   if (debug) cout<<" p = "<<p<<"  n = "<<n;
641   if ((p==-1)||(n==-1)) return;
642   
643   for(i=p;i<fNclustersP;i++)
644    {
645      pkg->AddPSideCluster(GetPSideClusterIdx(i));       
646    }
647   fNclustersP = p;
648   
649   for(i=n;i<fNclustersN;i++)
650    {
651      pkg->AddNSideCluster(GetNSideClusterIdx(i));       
652    }
653   fNclustersN = n;
654  
655   cout<<"  After split: fNclustersP = "<< fNclustersP<< "fNclustersN = "<< fNclustersN<<"\n";
656 }