]>
Commit | Line | Data |
---|---|---|
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 | } |