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