For Pythia with tune don't switch off MI in ConfigHeavyFlavor
[u/mrichter/AliRoot.git] / ITS / AliITSpackageSSD.cxx
index a9656e2..284bd20 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+/* $Id$ */
 
-/*
-$Log$
-*/
-
-#include <iostream.h>
+#include <Riostream.h>
 #include <TClonesArray.h>
 #include "AliITSpackageSSD.h"
-
-//************************************************
-//Piotr Krzysztof Skowronski
-//Warsaw University of Technology
-//skowron@if.pw.edu.pl
-//
+#include "AliITSclusterSSD.h"
 
 const Bool_t AliITSpackageSSD::fgkSIDEP=kTRUE;
 const Bool_t AliITSpackageSSD::fgkSIDEN=kFALSE;
 
-static const Int_t debug=0;
-
 ClassImp(AliITSpackageSSD)
-
-AliITSpackageSSD::AliITSpackageSSD()
-{
-  fNclustersN=0;
-  fClusterNIndexes = new TArrayI(300); 
-               
-  fNclustersP=0;
-  fClusterPIndexes = new TArrayI(300);
-  if (debug) cout<<"Default Ctor was used\n>>>>>>>>>>>>>><<<<<<<<<<<<<";
+////////////////////////////////////////////////////////////////////////////
+//Class describing set of AliITSoneSideClusterSSDs, which contact each other.
+//Piotr Krzysztof Skowronski
+//Warsaw University of Technology
+//skowron@if.pw.edu.pl
+//
+//--------------------------------------------------------------------------
+AliITSpackageSSD::AliITSpackageSSD():
+fClustersN(0),
+fClustersP(0),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
+  // constructor
 }
 
 
 /*******************************************************/
 
 AliITSpackageSSD::AliITSpackageSSD
-  (TClonesArray *clustersP, TClonesArray *clustersN)
-{
+(TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
+  // constructor
   fClustersP=clustersP;
   fClustersN=clustersN;
        
@@ -63,10 +65,14 @@ AliITSpackageSSD::AliITSpackageSSD
 /*******************************************************/
 
 
-AliITSpackageSSD::AliITSpackageSSD
-  ( Int_t len, TClonesArray *clustersP, TClonesArray *clustersN)
-
-{      
+AliITSpackageSSD::AliITSpackageSSD(Int_t len, TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){   
+  // constructor
   fClustersP=clustersP;
   fClustersN=clustersN;
 
@@ -86,20 +92,20 @@ AliITSpackageSSD::~AliITSpackageSSD()
   delete fClusterNIndexes;
   delete fClusterPIndexes;             
 }
+
 /*******************************************************/
 
-AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
-{
+AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) : 
+    TObject(package),
+fClustersN(package.fClustersN),
+fClustersP(package.fClustersP),
+fNclustersN(package.fNclustersN),
+fNclustersP(package.fNclustersP),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
   // copy constractor
   Int_t i;  //iterator
  
-  if (this == &package) return;
-  fClustersN = package.fClustersN;
-  fClustersP = package.fClustersP;
-  
-  fNclustersN= package.fNclustersN;
-  fNclustersP= package.fNclustersP;
-  
   for ( i =0; i<fNclustersN;i++)
     {
       fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
@@ -110,9 +116,6 @@ AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
       fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
     }
   
-  if (debug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
-  
-  return; 
   
 }
 /*******************************************************/
@@ -120,66 +123,69 @@ AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
 AliITSpackageSSD&  
 AliITSpackageSSD::operator=( const AliITSpackageSSD & package)
 {
-
-Int_t i;  //iterator
-if (this == &package) return *this;
-fClustersN = package.fClustersN;
-fClustersP = package.fClustersP;
-
-fNclustersN= package.fNclustersN;
-fNclustersP= package.fNclustersP;
-
-for ( i =0; i<fNclustersN;i++)
-  {
-    fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
-  }
-
-for ( i =0; i<fNclustersP;i++)
-  {
-    fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
-  }
-
-if (debug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
-
-return *this; 
+  //  assignment operator
+  //
+  Int_t i;  //iterator
+  
+  if (this == &package) return *this;
+  fClustersN = package.fClustersN;
+  fClustersP = package.fClustersP;
+  
+  fNclustersN= package.fNclustersN;
+  fNclustersP= package.fNclustersP;
+  
+  for ( i =0; i<fNclustersN;i++)
+    {
+      fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
+    }
+  
+  for ( i =0; i<fNclustersP;i++)
+    {
+      fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
+    }
+  
+  if (fgkDebug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
+  
+  return *this; 
   
 }
 
-
 /*******************************************************/
 
-Int_t 
-AliITSpackageSSD::GetNSideClusterIdx(Int_t index)
-
+Int_t AliITSpackageSSD::GetNSideClusterIdx(Int_t index) const
 {
+  // get N-side cluster
+  // 
   if ((index>-1)&&(index<fNclustersN))
     return (*fClusterNIndexes)[index];
   else 
-   {
-    cout << "AliITSpackageSSD::GetNSideClusterIdx  : Out of Range\n";
-    return -1;
-   }
+    {
+      cout << "AliITSpackageSSD::GetNSideClusterIdx  : Out of Range\n";
+      return -1;
+    }
 }
 /*******************************************************/
 
 
-Int_t AliITSpackageSSD::GetPSideClusterIdx(Int_t index)
+Int_t AliITSpackageSSD::GetPSideClusterIdx(Int_t index) const
 {
+  // get P-side cluster
+  //
   if ((index>-1)&&(index<fNclustersP))
     return (*fClusterPIndexes)[index];
   else 
-  {
-  cout << "AliITSpackageSSD::GetPSideClusterIdx  : Out of Range\n";
-   return -1;
-  } 
+    {
+      cout << "AliITSpackageSSD::GetPSideClusterIdx  : Out of Range\n";
+      return -1;
+    } 
 }
 /*******************************************************/
 AliITSclusterSSD*  
 AliITSpackageSSD::GetPSideCluster(Int_t index)
 {
-
-return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
+  // get Pside cluster from the TClonesArray of SSD clusters
+  //
+  return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
 }
 
 /*******************************************************/
@@ -187,86 +193,86 @@ return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
 AliITSclusterSSD*  
 AliITSpackageSSD::GetNSideCluster(Int_t index)
 {
-return (AliITSclusterSSD*)((*fClustersN)[GetNSideClusterIdx(index)]);
+  // get Nside cluster from the TClonesArray of SSD clusters
+  //
+  return (AliITSclusterSSD*)((*fClustersN)[GetNSideClusterIdx(index)]);
 }
 
 
 /*******************************************************/
 
-
-
-Bool_t 
-AliITSpackageSSD::GetClusterWithOneCross
-  (Int_t & index, Bool_t& side)
+Bool_t AliITSpackageSSD::GetClusterWithOneCross
+(Int_t & index, Bool_t& side)
 {
+  // select clusters with on cross 
+  //
+  if((fNclustersP==0)||(fNclustersN==0) )
+    {
+      printf("Empty package ((fNclustersP==0)||(fNclustersN==0))\n");
+      index = -2;
+      return kFALSE;
+    } 
+  Int_t ind;
   
- if((fNclustersP==0)||(fNclustersN==0) )
-  {
-    printf("Empty package ((fNclustersP==0)||(fNclustersN==0))\n");
-    index = -2;
-    return kFALSE;
-  } 
- Int_t ind;
-
- ind =(*fClusterPIndexes)[fNclustersP-1]; 
- if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo()  ) ==1 )
-  {
-    //index=ind;
-    index =fNclustersP-1; 
-    side=fgkSIDEP;
-    return kTRUE;
-  }
- ind =(*fClusterNIndexes)[fNclustersN-1]; 
- if (  (  ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo() ) ==1  )
-  {
-    //index=ind;
-    index = fNclustersN-1;
-    side=fgkSIDEN;
-    return kTRUE;
-  }
+  ind =(*fClusterPIndexes)[fNclustersP-1]; 
+  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo()  ) ==1 )
+    {
+      //index=ind;
+      index =fNclustersP-1; 
+      side=fgkSIDEP;
+      return kTRUE;
+    }
   
-
- ind =(*fClusterPIndexes)[0];
- if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo() ) ==1 )
-  {
-    //index=ind;
-    index = 0;
-    side=fgkSIDEP;
-    return kTRUE;
-  }
+  ind =(*fClusterNIndexes)[fNclustersN-1]; 
+  if (  (  ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo() ) ==1  )
+    {
+      //index=ind;
+      index = fNclustersN-1;
+      side=fgkSIDEN;
+      return kTRUE;
+    }
   
-
- ind =(*fClusterNIndexes)[0];
- if (  ( ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo()  ) ==1  )
-  {
-//    index=ind;
-    index = 0;  
-    side=fgkSIDEN;
-    return kTRUE;
-  }
+  
+  ind =(*fClusterPIndexes)[0];
+  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo() ) ==1 )
+    {
+      //index=ind;
+      index = 0;
+      side=fgkSIDEP;
+      return kTRUE;
+    }
+  
+  
+  ind =(*fClusterNIndexes)[0];
+  if (  ( ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo()  ) ==1  )
+    {
+      //    index=ind;
+      index = 0;  
+      side=fgkSIDEN;
+      return kTRUE;
+    }
   
   
- //Add for to be shure 
- index = -1;
- return kFALSE;
+  //Add for to be shure 
+  index = -1;
+  return kFALSE;
   
 }
 /*******************************************************/
 
 void AliITSpackageSSD::DelCluster(Int_t index, Bool_t side)
 {
+  // call DelPCluster or DelNCluster depending on side
+  //
   if(side==fgkSIDEP) DelPCluster(index); else DelNCluster(index);
 }
 /*******************************************************/
 void AliITSpackageSSD::DelPCluster(Int_t index)
 {
-
-//it not deletes delete given cluster physically, 
-//but only complytely erase it from package
-//all clusters are deleted automatically when TClonesArray is deleted
-
+  //it not deletes delete given cluster physically, 
+  //but only complytely erase it from package
+  //all clusters are deleted automatically when TClonesArray is deleted
+  
   Int_t i;
   Int_t idx;
   Int_t clToDelIdx = GetPSideClusterIdx(index); //Index of cluster in TClonesArray 
@@ -274,24 +280,24 @@ void AliITSpackageSSD::DelPCluster(Int_t index)
   Int_t ncr = clToDel->GetCrossNo();
   
   for (i =0;i<ncr;i++)
-   {
-    idx = clToDel->GetCross(i);
-    ((AliITSclusterSSD *)((*fClustersN)[idx])   )->DelCross(clToDelIdx);
-   }
- for (i=index;i<fNclustersP-1;i++)
-  {
-       (*fClusterPIndexes)[i]=(*fClusterPIndexes)[i+1];
-  }
- fNclustersP--; 
- if (debug) cout<<"Cluster P ("<<index<<") deleted\n";
-
-
- for (i=0;i<fNclustersN;i++)
-  {
-    if ( (GetNSideCluster(i)->GetCrossNo())==0) DelNCluster(i);
-  }
+    {
+      idx = clToDel->GetCross(i);
+      ((AliITSclusterSSD *)((*fClustersN)[idx])   )->DelCross(clToDelIdx);
+    }
+  
+  
+  for (i=index;i<fNclustersP-1;i++)
+    {
+      (*fClusterPIndexes)[i]=(*fClusterPIndexes)[i+1];
+    }
+  fNclustersP--; 
+  if (fgkDebug) cout<<"Cluster P ("<<index<<") deleted\n";
+  
+  
+  for (i=0;i<fNclustersN;i++)
+    {
+      if ( (GetNSideCluster(i)->GetCrossNo())==0) DelNCluster(i);
+    }
 }
 
 
@@ -299,11 +305,10 @@ void AliITSpackageSSD::DelPCluster(Int_t index)
 /*******************************************************/
 void AliITSpackageSSD::DelNCluster(Int_t index)
 {
-
-//it not deletes delete given cluster physically, 
-//but only complytely erase it from package
-//all clusters are deleted automatically when TClonesArray is deleted
-
+  //it not deletes delete given cluster physically, 
+  //but only complytely erase it from package
+  //all clusters are deleted automatically when TClonesArray is deleted
+  
   Int_t i;
   Int_t idx;
   Int_t clToDelIdx = GetNSideClusterIdx(index); //Index of cluster in TClonesArray 
@@ -311,24 +316,24 @@ void AliITSpackageSSD::DelNCluster(Int_t index)
   Int_t ncr = clToDel->GetCrossNo();
   
   for (i =0;i<ncr;i++)
-   {
-    idx = clToDel->GetCross(i);
-    ((AliITSclusterSSD *)((*fClustersP)[idx])   )->DelCross(clToDelIdx);
-   }
- for (i=index;i<fNclustersN-1;i++)
-  {
-       (*fClusterNIndexes)[i]=(*fClusterNIndexes)[i+1];
-  }
- fNclustersN--; 
- if (debug) cout<<"Cluster N ("<<index<<") deleted\n";
-
- for (i=0;i<fNclustersP;i++)
-  {
-    if ( (GetPSideCluster(i)->GetCrossNo())==0) DelPCluster(i);
-  }
-
+    {
+      idx = clToDel->GetCross(i);
+      ((AliITSclusterSSD *)((*fClustersP)[idx])   )->DelCross(clToDelIdx);
+    }
+  
+  
+  for (i=index;i<fNclustersN-1;i++)
+    {
+      (*fClusterNIndexes)[i]=(*fClusterNIndexes)[i+1];
+    }
+  fNclustersN--; 
+  if (fgkDebug) cout<<"Cluster N ("<<index<<") deleted\n";
+  
+  for (i=0;i<fNclustersP;i++)
+    {
+      if ( (GetPSideCluster(i)->GetCrossNo())==0) DelPCluster(i);
+    }
+  
 }
 
 
@@ -336,7 +341,7 @@ void AliITSpackageSSD::DelNCluster(Int_t index)
 
 void AliITSpackageSSD::DelPClusterOI(Int_t index)
 {
-//This function looks like this, 
+  //This function looks like this, 
 //because probably cut cluster is 
 //on the beginning or on the end of package 
  Int_t i;
@@ -412,6 +417,7 @@ void AliITSpackageSSD::DelNClusterOI(Int_t index)
 
 void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
 {
+  // delete cluster
  if (side == fgkSIDEP)
   {    
     DelPClusterOI(index);
@@ -429,19 +435,19 @@ void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
 
 void  AliITSpackageSSD::GetAllCombinations(Int_t**array,Int_t &num,Int_t sizet)
 {
-  
+  // get all combinations
   Int_t *takenNcl = new Int_t[fNclustersN];
   
   num=0;
   
-  if (debug) PrintClusters();
+  if (fgkDebug) PrintClusters();
 
   for (Int_t i=0;i<fNclustersP;i++)
    {
      takenNcl[i]=-1;
    }
   //see comment on the beginning of MakeCombin
-  if (debug) cout<<"GetAllCombinations entered";
+  if (fgkDebug) cout<<"GetAllCombinations entered";
   MakeCombin (array,num,0,takenNcl,sizet);
 
   delete []takenNcl; 
@@ -453,7 +459,6 @@ void  AliITSpackageSSD::MakeCombin
    (Int_t**arr,Int_t& nu, Int_t np, Int_t *occup, Int_t sizet)
 
 {
-
 //ATTENTION: anybody watching this function
 //AliITSclusterSSD::GetCrossNo() returns index of cluster in main array belonging to AliITSmodulesSSD
 //however, we have pointer to that array (TClonesArray)
@@ -465,12 +470,12 @@ void  AliITSpackageSSD::MakeCombin
  //this cluster
  AliITSclusterSSD *cl=GetPSideCluster(np);
 
- Int_t NC = cl->GetCrossNo();  //number of crosses for this cluster
+ Int_t nc = cl->GetCrossNo();  //number of crosses for this cluster
  Int_t indcro;                 //index of given cluster on side N that 
                                // this cluster crosses with
    
  if (np == fNclustersP-1) {
-   for (i=0;i<NC;i++) {
+   for (i=0;i<nc;i++) {
      indcro=cl->GetCross(i);
      if(IsFree(indcro,np,occup)) {
         occup[np]=indcro;
@@ -486,7 +491,7 @@ void  AliITSpackageSSD::MakeCombin
      }
    }
   } else {
-    for (i=0;i<NC;i++) {
+    for (i=0;i<nc;i++) {
        indcro=cl->GetCross(i);
        if(IsFree(indcro,np,occup)) {
          occup[np]=indcro;
@@ -500,9 +505,9 @@ void  AliITSpackageSSD::MakeCombin
 }
 
 /**********************************************/
-Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, Int_t *lis)
+Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, const Int_t *lis) const
 {
-
+  // 
   for (Int_t i=0;i<nn;i++)
     {
       if (lis[i]==idx) return kFALSE;
@@ -513,7 +518,7 @@ Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, Int_t *lis)
 /**********************************************/
 void AliITSpackageSSD::PrintClusters()
 {
-
+  // print cluster info
 Int_t i,j;
 cout<<"SIDE P\n";
 for (i=0;i<fNclustersP;i++)
@@ -542,29 +547,29 @@ for (i=0;i<fNclustersN;i++)
     cout<<"\n";   
  }
  
 }
+
 /**********************************************/
 void AliITSpackageSSD::ConsumeClusters()
 {
-register Int_t i;
-
-for(i=0;i<fNclustersP;i++)
- {
-   GetPSideCluster(i)->Consume();
- }
-
-for(i=0;i<fNclustersN;i++)
- {
-   GetNSideCluster(i)->Consume();
- }
-
+  // consume cluster
+  register Int_t i;
+  
+  for(i=0;i<fNclustersP;i++)
+    {
+      GetPSideCluster(i)->Consume();
+    }
+  
+  for(i=0;i<fNclustersN;i++)
+    {
+      GetNSideCluster(i)->Consume();
+    }
+  
 }
 
 /**********************************************/
 
-Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI)
+Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI) const
 {
  //Returns index of next P cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
@@ -575,8 +580,9 @@ Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI)
   }
  return -1;
 }
+
 /**********************************************/
-Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI)
+Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI) const
 {
  //Returns index of previous P cluster  OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
@@ -589,7 +595,7 @@ Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI)
   return -1;
 }
 /**********************************************/
-Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI)
+Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI) const
 {
 //Returns index of next N cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
@@ -602,7 +608,7 @@ Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI)
 
 }
 /**********************************************/
-Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI)
+Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI) const
 {
  //Returns index of previous N cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
@@ -638,7 +644,9 @@ void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
        break;
       }
     }  
-  if (debug) cout<<" p = "<<p<<"  n = "<<n;
+  if (fgkDebug) {
+    cout<<" p = "<<p<<"  n = "<<n;
+  }
   if ((p==-1)||(n==-1)) return;
   
   for (i=p;i<fNclustersP;i++)