ITS/AliITSTableSSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2002-2003, 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 #include <Riostream.h>
  17 #include "AliITSTableSSD.h"
  18
  19 using std::endl;
  20 using std::cout;
  21 using std::cerr;
  22 ClassImp(AliITSTableSSD)
  23 ////////////////////////////////////////////////////////////////////////
  24 // Version: 0                                                         //
  25 // Origin: Massimo Masera                                             //
  26 // March 2002                                                         //
  27 //                                                                    //
  28 // AliITSTableSSD is used by AliITSsimulationSSD class to fill the AliITSpList
  29 // object starting from the map with energy depositions
  30 ////////////////////////////////////////////////////////////////////////
  31 //----------------------------------------------------------------------
  32 AliITSTableSSD::AliITSTableSSD() : TObject(),
  33 fDim(0),
  34 fArray(0){
  35   // Default Constructor
  36   for(Int_t i=0;i<2;i++){
  37     fCurrUse[i]=0;
  38     fCurrFil[i]=0;
  39   }
  40 }
  41 //----------------------------------------------------------------------
  42 AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source),
  43 fDim(source.fDim),
  44 fArray(source.fArray){
  45   // Copy constructor
  46
  47     if(this == &source) return;
  48     fArray = new Int_t [fDim];
  49     fCurrUse[0]=(source.fCurrUse)[0];
  50     fCurrUse[1]=(source.fCurrUse)[1];
  51     fCurrFil[0]=(source.fCurrFil)[0];
  52     fCurrFil[1]=(source.fCurrFil)[1];
  53     for(Int_t i=0;i<fDim;i++)fArray[i]=(source.fArray)[i];
  54 }
  55 //----------------------------------------------------------------------
  56 AliITSTableSSD& AliITSTableSSD::operator=(const AliITSTableSSD & source){
  57   // = opporator constructor
  58
  59     if(this == &source) return *this;
  60     fDim=source.fDim;
  61     if(fArray)delete [] fArray;
  62     fArray = new Int_t [fDim];
  63     fCurrUse[0]=(source.fCurrUse)[0];
  64     fCurrUse[1]=(source.fCurrUse)[1];
  65     fCurrFil[0]=(source.fCurrFil)[0];
  66     fCurrFil[1]=(source.fCurrFil)[1];
  67     for(Int_t i=0;i<fDim;i++)fArray[i]=(source.fArray)[i];
  68     return *this;
  69 }
  70 //----------------------------------------------------------------------
  71 AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(),
  72 fDim(0),
  73 fArray(0){
  74   // Standard constructor
  75   fDim=noelem*2;
  76   fArray = new Int_t [fDim];
  77   Clear();
  78 }
  79 //----------------------------------------------------------------------
  80 AliITSTableSSD::~AliITSTableSSD(){
  81   // Destructor
  82   delete [] fArray;
  83   fArray=0;
  84 }
  85 //----------------------------------------------------------------------
  86 void AliITSTableSSD::Add(Int_t side,Int_t strip){
  87   // Add an element to the table
  88   if(strip>=fDim/2){
  89     cerr<<" Error in AliITSTableSSD::Add. "<<strip<<" is out of range\n";
  90     return;
  91   }
  92   if((side!=0) && (side!=1)){
  93     cerr<<" Error in AliITSTableSSD::Add. side="<<side<<endl;
  94     cerr<<" side must be 0 or 1\n";
  95     return;
  96   }
  97   if(fCurrFil[side]>(fDim/2-1)){
  98     cerr<<" Error in AliITSTableSSD::Add. Trying to fill an element out of range\n";
  99     cerr<<" Element="<<fCurrFil[side]<<" while max limit is "<<(fDim/2-1)<<endl;
 100     fCurrFil[side]++;
 101     return;
 102   }
 103   // P side = 0 and N side =1
 104   Int_t index=(fDim/2)*side+fCurrFil[side];
 105   Int_t * ptr= &fArray[(fDim/2)*side];
 106   if(SearchValue(ptr,strip,fCurrFil[side])>=0)return;
 107   fArray[index]=strip;
 108   fCurrFil[side]++;
 109 }
 110 //----------------------------------------------------------------------
 111 void AliITSTableSSD::Clear(){
 112   //clear arrays
 113   fCurrUse[0]= 0;
 114   fCurrUse[1] = 0;
 115   fCurrFil[0]= 0;
 116   fCurrFil[1] = 0;
 117   for(Int_t i=0;i<fDim;i++)fArray[i]=-1;
 118 }
 119 //----------------------------------------------------------------------
 120 void AliITSTableSSD::DumpTable(){
 121   // Dumps the contents of the table
 122   cout<<"==============================================================\n";
 123   cout<<" AliITSTableSSD::DumpTable \n";
 124   cout<<" Dimension of the table "<<fDim<<" ("<<fDim/2<<" per side)\n";
 125   cout<<" Current element to be filled for P side "<<fCurrFil[0]<<endl;
 126   cout<<" Current element to be filled for N side "<<fCurrFil[1]<<endl;
 127   cout<<" Current element in use for P side "<<fCurrUse[0]<<endl;
 128   cout<<" Current element in use for N side "<<fCurrUse[1]<<endl;
 129   cout<<"\n Elements for P side: \n";
 130   for(Int_t i=0; i<fCurrFil[0];i++){
 131     printf("%6d ",fArray[i]);
 132     if(i%6==0 && i>0)printf("\n");
 133   }
 134   printf("\n");
 135   cout<<"\n Elements for N side: \n";
 136   for(Int_t i=0; i<fCurrFil[1];i++){
 137     printf("%6d ",fArray[fDim/2+i]);
 138     if(i%6==0 && i>0)printf("\n");
 139   }
 140   printf("\n");
 141 }
 142
 143 //----------------------------------------------------------------------
 144 Int_t AliITSTableSSD::Use(Int_t side){
 145   // uses the current element. This means that the current element is returned
 146   // and its content is replaced by -1. Hence each element can be used only
 147   // once.
 148   Int_t elem=-1;
 149   if((side!=0) && (side!=1)){
 150     cerr<<" Error in AliITSTableSSD::Use. side="<<side<<endl;
 151     cerr<<" side must be 0 or 1\n";
 152     return elem;
 153   }
 154   if(fCurrUse[side]>(fDim/2-1)){
 155     cerr<<" Error in AliITSTableSSD::Use. Trying to use an element out of range\n";
 156     cerr<<" Element="<<fCurrUse[side]<<" while max limit is "<<(fDim/2-1)<<endl;
 157     fCurrUse[side]++;
 158     return elem;
 159   }
 160   Int_t index=(fDim/2)*side+fCurrUse[side];
 161   elem=fArray[index];
 162   fArray[index]=-1;
 163   fCurrUse[side]++;
 164   return elem;
 165 }