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