Moving required CMake version from 2.8.4 to 2.8.8
[u/mrichter/AliRoot.git] / ITS / AliITSBadChannelsSPD.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 /*
17 $Log$
18 Revision 1.2  2005/11/03 13:09:19  hristov
19 Removing meaningless const declarations (linuxicc)
20
21 Revision 1.1  2005/10/11 12:31:50  masera
22 Preprocessor classes for SPD (Paul Nilsson)
23
24 */
25
26 ///////////////////////////////////////////////////////////////////////////
27 // AliITSBadChannelsSPD implementation by P. Nilsson 2005
28 // AUTHOR/CONTACT: Paul.Nilsson@cern.ch
29 //
30 // The class is used by the AliITSPreprocessorSPD class to store the
31 // final noisy and dead channel objects in the calibration database for
32 // the SPD.
33 //
34 // An instance of this container class contains all the "bad" channels,
35 // i.e. the noisy or dead channels of the SPD. It contains TObjArrays
36 // for each module of the SPD (240 in total for ALICE, and 6 for the 2004
37 // joint ITS beam test. The instance object should, once filled with data,
38 // be stored in the calibration database. This is done by the SPD
39 // preprocessor.
40 ///////////////////////////////////////////////////////////////////////////
41
42 #include "AliITSBadChannelsSPD.h"
43
44 ClassImp(AliITSBadChannelsSPD)
45
46 //__________________________________________________________________________
47 AliITSBadChannelsSPD::AliITSBadChannelsSPD(void) :
48   fIndexArraySize(0),
49   fBadChannelsArraySize(0),
50   fIndexArray(0x0),
51   fBadChannelsArray(0x0)
52 {
53   // Default constructor
54 }
55
56 //__________________________________________________________________________
57 AliITSBadChannelsSPD::AliITSBadChannelsSPD(const AliITSBadChannelsSPD &bc) :
58   TObject(bc),
59 fIndexArraySize(bc.fIndexArraySize),
60 fBadChannelsArraySize(bc.fBadChannelsArraySize),
61 fIndexArray(0),
62 fBadChannelsArray(0){
63   // Default copy constructor
64
65   // Create new arrays
66   fIndexArray = new Int_t[fIndexArraySize];
67   fBadChannelsArray = new Int_t[fBadChannelsArraySize];
68
69   // Copy arrays
70   for (Int_t i = 0; i < fIndexArraySize; i++)
71     {
72       fIndexArray[i] = bc.fIndexArray[i];
73     }
74   for (Int_t i = 0; i < fBadChannelsArraySize; i++)
75     {
76       fBadChannelsArray[i] = bc.fBadChannelsArray[i];
77     }
78 }
79
80 //__________________________________________________________________________
81 AliITSBadChannelsSPD::~AliITSBadChannelsSPD(void)
82 {
83   // Default destructor
84
85   delete [] fIndexArray;
86   fIndexArray = 0;
87   delete [] fBadChannelsArray;
88   fBadChannelsArray = 0;
89 }
90
91 //__________________________________________________________________________
92 AliITSBadChannelsSPD& AliITSBadChannelsSPD::operator=(const AliITSBadChannelsSPD &bc)
93 {
94   // Assignment operator
95   
96   // Guard against self-assignment
97   if (this != &bc)
98     {
99       // Copy array sizes
100       fIndexArraySize = bc.fIndexArraySize;
101       fBadChannelsArraySize = bc.fBadChannelsArraySize;
102
103       delete [] fIndexArray;
104       fIndexArray = new Int_t[fIndexArraySize];
105
106       delete [] fBadChannelsArray;
107       fBadChannelsArray = new Int_t[fBadChannelsArraySize];
108
109       // Copy arrays
110       for (Int_t i = 0; i < fIndexArraySize; i++)
111         {
112           fIndexArray[i] = bc.fIndexArray[i];
113         }
114       for (Int_t i = 0; i < fBadChannelsArraySize; i++)
115         {
116           fBadChannelsArray[i] = bc.fBadChannelsArray[i];
117         }
118     }
119
120   return *this;
121 }
122
123
124 //__________________________________________________________________________
125 void AliITSBadChannelsSPD::Put(Int_t* &badChannelsArray, const Int_t &badChannelsArraySize,
126                                Int_t* &indexArray, const Int_t &indexArraySize)
127 {
128   // Add the bad channels and index arrays
129
130   fIndexArraySize = indexArraySize;
131   fBadChannelsArraySize = badChannelsArraySize;
132
133   fIndexArray = new Int_t[fIndexArraySize];
134   fBadChannelsArray = new Int_t[fBadChannelsArraySize];
135
136   // Copy the arrays
137   for (Int_t i = 0; i < fIndexArraySize; i++)
138     {
139       fIndexArray[i] = indexArray[i];
140     }
141   for (Int_t i = 0; i < fBadChannelsArraySize; i++)
142     {
143       fBadChannelsArray[i] = badChannelsArray[i];
144     }
145
146 }
147
148 //__________________________________________________________________________
149 Bool_t AliITSBadChannelsSPD::Get(Int_t* &badChannelsArray, Int_t* &indexArray) const
150 {
151   // Get the bad channels and the index arrays
152
153   Bool_t status = kTRUE;
154
155   // Set the array pointers
156   if (fIndexArraySize > 0)
157     {
158       badChannelsArray = fBadChannelsArray;
159       indexArray = fIndexArray;
160     }
161   else
162     {
163       status = kFALSE;
164     }
165
166   return status;
167 }
168
169 //__________________________________________________________________________
170 Int_t* AliITSBadChannelsSPD::CreateModuleArray(Int_t module) const
171 {
172   // Create an Int_t array for a given module
173
174   Int_t *moduleArray = 0;
175
176   const Int_t kSize = AliITSBadChannelsSPD::GetModuleArraySize(module);
177   if (kSize > 0)
178     {
179       // Create a new array
180       moduleArray = new Int_t[kSize];
181
182       // Copy the module data into the module array from the bad channels array
183       const Int_t kPosition = fIndexArray[module];
184       for (Int_t index = 0; index < kSize; index++)
185         {
186           moduleArray[index] = fBadChannelsArray[kPosition + index];
187         }
188     }
189
190   return moduleArray;
191 }
192
193 //__________________________________________________________________________
194 TObjArray* AliITSBadChannelsSPD::CreateModuleObjArray(Int_t module) const
195 {
196   // Create a TObjArray for a given module
197
198   TObjArray *moduleArray = 0;
199
200   const Int_t kSize = AliITSBadChannelsSPD::GetModuleObjArraySize(module);
201   if (kSize > 0)
202     {
203       // Create a new array
204       moduleArray = new TObjArray(kSize);
205
206       // Copy the module data into the module array from the bad channels array
207
208       // Get the start position of the data (skip the number of bad channels, i.e. the first stored number)
209       Int_t position = fIndexArray[module] + 1;
210
211       Int_t i = 0;
212       while (i < kSize)
213         {
214           // Create and add the current channel
215           Int_t p1 = position++;
216           Int_t p2 = position++;
217           AliITSChannelSPD *channel = new AliITSChannelSPD(fBadChannelsArray[p1], fBadChannelsArray[p2]);
218           moduleArray->Add(channel);
219
220           // Go to next bad channel
221           i++;
222         }
223     }
224
225   return moduleArray;
226 }