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