Activate delta-electrons for RICH

[u/mrichter/AliRoot.git] / ITS / AliITSpackageSSD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log$
*/

#include <iostream.h>
#include <TClonesArray.h>
#include "AliITSpackageSSD.h"

//************************************************
//Piotr Krzysztof Skowronski
//Warsaw University of Technology
//skowron@if.pw.edu.pl
//

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>>>>>>>>>>>>>><<<<<<<<<<<<<";
}


/*******************************************************/

AliITSpackageSSD::AliITSpackageSSD
  (TClonesArray *clustersP, TClonesArray *clustersN)
{
  fClustersP=clustersP;
  fClustersN=clustersN;
  	
  fNclustersN=0;
  fClusterNIndexes = new TArrayI(300); 
	
  fNclustersP=0;
  fClusterPIndexes = new TArrayI(300);		
}

/*******************************************************/


AliITSpackageSSD::AliITSpackageSSD
  ( Int_t len, TClonesArray *clustersP, TClonesArray *clustersN)

{	
  fClustersP=clustersP;
  fClustersN=clustersN;

  fNclustersN=0;
  fClusterNIndexes = new TArrayI(len); 
	
  fNclustersP=0;
  fClusterPIndexes = new TArrayI(len);		
}


/*******************************************************/

AliITSpackageSSD::~AliITSpackageSSD()
{
  // destructor
  delete fClusterNIndexes;
  delete fClusterPIndexes;		
}
/*******************************************************/

AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
{
  // 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]; 
    }
  
  for ( i =0; i<fNclustersP;i++)
    {
      fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
    }
  
  if (debug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
  
  return; 
  
}
/*******************************************************/

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; 
  
}


/*******************************************************/

Int_t 
AliITSpackageSSD::GetNSideClusterIdx(Int_t index)

{
  if ((index>-1)&&(index<fNclustersN))
    return (*fClusterNIndexes)[index];
  else 
   {
    cout << "AliITSpackageSSD::GetNSideClusterIdx  : Out of Range\n";
    return -1;
   }
}
/*******************************************************/


Int_t AliITSpackageSSD::GetPSideClusterIdx(Int_t index)
{
  if ((index>-1)&&(index<fNclustersP))
    return (*fClusterPIndexes)[index];
  else 
  {
  cout << "AliITSpackageSSD::GetPSideClusterIdx  : Out of Range\n";
   return -1;
  } 
}
/*******************************************************/
AliITSclusterSSD*  
AliITSpackageSSD::GetPSideCluster(Int_t index)
{

return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
}

/*******************************************************/

AliITSclusterSSD*  
AliITSpackageSSD::GetNSideCluster(Int_t index)
{
return (AliITSclusterSSD*)((*fClustersN)[GetNSideClusterIdx(index)]);
}


/*******************************************************/



Bool_t 
AliITSpackageSSD::GetClusterWithOneCross
  (Int_t & index, Bool_t& side)
{
  
 
 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)[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;
  
}
/*******************************************************/

void AliITSpackageSSD::DelCluster(Int_t index, Bool_t 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

  Int_t i;
  Int_t idx;
  Int_t clToDelIdx = GetPSideClusterIdx(index); //Index of cluster in TClonesArray 
  AliITSclusterSSD *clToDel = GetPSideCluster(index); //cluster to be deleted
  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);
  }
}



/*******************************************************/
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

  Int_t i;
  Int_t idx;
  Int_t clToDelIdx = GetNSideClusterIdx(index); //Index of cluster in TClonesArray 
  AliITSclusterSSD *clToDel = GetNSideCluster(index); //cluster to be deleted
  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);
  }

}


/*******************************************************/

void AliITSpackageSSD::DelPClusterOI(Int_t index)
{
//This function looks like this, 
//because probably cut cluster is 
//on the beginning or on the end of package 
 Int_t i;
 if( ((*fClusterPIndexes)[0]) == index) 
  {
    DelPCluster(0);
    return;
  }
 else
  { 
   if( ((*fClusterPIndexes)[fNclustersP-1]) ==index)
    {
      DelPCluster(fNclustersP-1);
      return;
    }
   else
    {
     for (i=1;i<fNclustersP-1;i++)
       {
         if( ((*fClusterPIndexes)[i])==index)
	  {
            DelPCluster(i);
            return;
	  }
       }
    }
  }
 
 cout<<"AliITSpackageSSD - DelPClusterOI: index "<<index<<" not found\n";

}


/*******************************************************/

void AliITSpackageSSD::DelNClusterOI(Int_t index)
{
//This function looks like this, 
//because probably cluster to cut is 
//on the beginning or on the end of package 

 Int_t i;
 if( ((*fClusterNIndexes)[0])==index) 
  {
    DelNCluster(0);
    return;
  }
 else
  { 
   if( ((*fClusterNIndexes)[fNclustersN-1])==index)
    {
      DelNCluster(fNclustersN-1);
      return;
    }
   else
    {
     for (i=1;i<fNclustersN-1;i++)
       {
         if( ((*fClusterNIndexes)[i])==index)
         {
          DelNCluster(i);
          return;
         }
       }
    }
  }
 cout<<"AliITSpackageSSD - DelNClusterOI: index "<<index<<" not found\n";
}


/*******************************************************/


void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
{
 if (side == fgkSIDEP)
  {    
    DelPClusterOI(index);
  } 
  else
  {
    DelNClusterOI(index);
  }

}


/**********************************************/


void  AliITSpackageSSD::GetAllCombinations(Int_t**array,Int_t &num,Int_t sizet)
{
  
  Int_t *takenNcl = new Int_t[fNclustersN];
  
  num=0;
  
  if (debug) PrintClusters();

  for (Int_t i=0;i<fNclustersP;i++)
   {
     takenNcl[i]=-1;
   }
  //see comment on the beginning of MakeCombin
  if (debug) cout<<"GetAllCombinations entered";
  MakeCombin (array,num,0,takenNcl,sizet);

  delete []takenNcl; 
}
/**********************************************/


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)
//we can not use 
//Get?SideCluster because it takes index from local look_up_table
 
 Int_t i,j;
 
 //this cluster
 AliITSclusterSSD *cl=GetPSideCluster(np);

 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++) {
     indcro=cl->GetCross(i);
     if(IsFree(indcro,np,occup)) {
        occup[np]=indcro;
        for(j=0;j<fNclustersP;j++)  
        {
	   if (nu<sizet) arr[nu][j]=occup[j];
	   else {
	       continue;}
        }
      
        occup[np]=-1;
        if (nu<sizet-1) nu++;
     }
   }
  } else {
    for (i=0;i<NC;i++) {
       indcro=cl->GetCross(i);
       if(IsFree(indcro,np,occup)) {
      	  occup[np]=indcro;
	  if (nu<sizet) MakeCombin(arr,nu,(np+1),occup,sizet);
	  //else printf("MakeComb - exceeding array size!\n");
       }
    }
    occup[np]=-1;
  } 

}

/**********************************************/
Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, Int_t *lis)
{

  for (Int_t i=0;i<nn;i++)
    {
      if (lis[i]==idx) return kFALSE;
    }
  return kTRUE;
}

/**********************************************/
void AliITSpackageSSD::PrintClusters()
{

Int_t i,j;
cout<<"SIDE P\n";
for (i=0;i<fNclustersP;i++)
 {
   cout<<i<<".  IO="<<GetPSideClusterIdx(i)<<" NC="<<GetPSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
   for (j=0;j<GetPSideCluster(i)->GetCrossNo();j++)
    {
      cout<<GetPSideCluster(i)->GetCross(j)<<" ";
    }
 //  if (GetPSideCluster(i)->GetSide()) cout<<" P\n";
 //  else cout<<"BAD SIDE ==N\n";
    cout<<"\n";
   
 }

cout <<"SIDE N\n";
for (i=0;i<fNclustersN;i++)
 {
   cout<<i<<".  IO="<<GetNSideClusterIdx(i)<<" NC="<<GetNSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
   for (j=0;j<GetNSideCluster(i)->GetCrossNo();j++)
    {
      cout<<GetNSideCluster(i)->GetCross(j)<<" ";
    }
 //  if (GetNSideCluster(i)->GetSide()) cout<<" N\n";
 //  else cout<<"BAD SIDE ==P\n";
    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();
 }

}

/**********************************************/

Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI)
{
 //Returns index of next P cluster OI in package; OI == Original Inedx (in TClonesArray)
 //if not egsist return -1;
 for (Int_t i =0; i<fNclustersP-1;i++)
  {
    if(GetPSideClusterIdx(i) == OI)
       return GetPSideClusterIdx(i+1);
  }
 return -1;
}
/**********************************************/
Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI)
{
 //Returns index of previous P cluster  OI in package; OI == Original Inedx (in TClonesArray)
 //if not egsist return -1;
 
 for (Int_t i =1; i<fNclustersP;i++)
  {
    if(GetPSideClusterIdx(i) == OI)
       return GetPSideClusterIdx(i-1);
  }
  return -1;
}
/**********************************************/
Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI)
{
//Returns index of next N cluster OI in package; OI == Original Inedx (in TClonesArray)
 //if not egsist return -1;
 for (Int_t i =0; i<fNclustersN-1;i++)
  {
    if(GetNSideClusterIdx(i) == OI)
       return GetNSideClusterIdx(i+1);
  }
 return -1;

}
/**********************************************/
Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI)
{
 //Returns index of previous N cluster OI in package; OI == Original Inedx (in TClonesArray)
 //if not egsist return -1;
 
 for (Int_t i =1; i<fNclustersN;i++)
  {
    if(GetNSideClusterIdx(i) == OI)
       return GetNSideClusterIdx(i-1);
  }
  return -1;
 
}

void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
{
  // split package of clusters
  Int_t p=-1, n=-1;
  Int_t i;
  for (i=0;i<fNclustersN;i++)
   {
     if((*fClusterNIndexes)[i]==ni) 
      {
        n = i;
	break;
      }
    } 
   
  for (i=0;i<fNclustersP;i++)
   {
     if((*fClusterPIndexes)[i]==pi) 
      {
        p = i;
	break;
      }
    }  
  if (debug) cout<<" p = "<<p<<"  n = "<<n;
  if ((p==-1)||(n==-1)) return;
  
  for (i=p;i<fNclustersP;i++)
   {
     pkg->AddPSideCluster(GetPSideClusterIdx(i));       
   }
  fNclustersP = p;
  
  for (i=n;i<fNclustersN;i++)
   {
     pkg->AddNSideCluster(GetNSideClusterIdx(i));       
   }
  fNclustersN = n;
 
  cout<<"  After split: fNclustersP = "<< fNclustersP<< "fNclustersN = "<< fNclustersN<<"\n";
}