Merge branch 'master' into TPCdev
[u/mrichter/AliRoot.git] / 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 }