* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-
-$Log$
-Revision 1.3 2000/06/30 12:07:49 kowal2
-Updated from the TPC-PreRelease branch
-
-Revision 1.2.4.3 2000/06/26 07:39:42 kowal2
-Changes to obey the coding rules
-
-Revision 1.2.4.2 2000/06/25 08:38:41 kowal2
-Splitted from AliTPCtracking
-
-Revision 1.2.4.1 2000/06/14 16:45:13 kowal2
-Improved algorithms. Compiler warnings removed.
-
-Revision 1.2 2000/04/17 09:37:33 kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2 2000/04/10 11:37:42 kowal2
-
-Digits handling in a new data structure
-
-*/
+/* $Id$ */
/*MI change -- for Rule checker
-- added copy constructor and assignmet operator
#include "TClass.h"
-#include <iostream.h>
+#include <Riostream.h>
#include "TError.h"
#include "AliSegmentID.h"
#include "AliH2F.h"
-#include "AliArrayI.h"
-#include "AliArrayS.h"
+#include <TArrayI.h>
+#include <TArrayS.h>
#include "AliDigits.h"
ClassImp(AliDigits)
-AliDigits::AliDigits()
+ AliDigits::AliDigits()
+ :AliSegmentID(),
+ fNrows(0),
+ fNcols(0),
+ fElements(0),
+ fIndex(0),
+ fBufType(0),
+ fThreshold(0),
+ fNelems(0),
+ fCurrentRow(0),
+ fCurrentCol(0),
+ fCurrentIndex(0)
{
//
//default constructor
- fIndex = 0;
- fElements = 0;
- fThreshold =0;
+ //
Invalidate();
}
AliDigits::AliDigits(const AliDigits& digits)
+ :AliSegmentID(digits),
+ fNrows(0),
+ fNcols(0),
+ fElements(0),
+ fIndex(0),
+ fBufType(0),
+ fThreshold(0),
+ fNelems(0),
+ fCurrentRow(0),
+ fCurrentCol(0),
+ fCurrentIndex(0)
{
//
//copy constructor
+ //
fNrows = digits.fNrows;
fNcols = digits.fNcols;
- fElements = new AliArrayS(*(digits.fElements));
- fIndex = new AliArrayI(*(digits.fIndex));
+ fElements = new TArrayS(*(digits.fElements));
+ fIndex = new TArrayI(*(digits.fIndex));
fBufType = digits.fBufType;
fThreshold = digits.fThreshold;
fNelems = digits.fNelems;
fNrows = digits.fNrows;
fNcols = digits.fNcols;
if (fElements) delete fElements;
- fElements = new AliArrayS(*(digits.fElements));
+ fElements = new TArrayS(*(digits.fElements));
if (fIndex) delete fIndex;
- fIndex = new AliArrayI(*(digits.fIndex));
+ fIndex = new TArrayI(*(digits.fIndex));
fBufType = digits.fBufType;
fThreshold = digits.fThreshold;
fNelems = digits.fNelems;
Bool_t AliDigits::OutOfBoundsError(const char *where, Int_t row, Int_t column)
{
// Generate an out-of-bounds error. Always returns false.
- ::Error(where, "row %d col %d out of bounds (size: %d x %d, this: 0x%08x)",
- row, column, fNrows, fNcols, this);
+ ::Error(where, "row %d col %d out of bounds (size: %d x %d, this: 0x%08lx)",
+ row, column, fNrows, fNcols, (ULong_t) this);
return kFALSE;
}
//
//set default (invalid parameters)
if (fIndex != 0) delete fIndex;
- fIndex = new AliArrayI;
+ fIndex = new TArrayI;
if (fElements!= 0) delete fElements;
- fElements = new AliArrayS;
+ fElements = new TArrayS;
fNrows = fNcols =fNelems= -1;
fElements->Set(0);
Int_t AliDigits::GetSize()
{
//
- //return size of object
+ //return size of object as represented in the memory
//
- Int_t size = sizeof(this);
+ // Int_t size = sizeof(this);
+ Int_t size = 0; // COVERITY consider the previous statment as bug
+ //
if (fIndex!=0) size+= sizeof(fIndex)+fIndex->GetSize()*sizeof(Int_t);
if (fElements!=0) size+= sizeof(fElements)+fElements->GetSize()*sizeof(Short_t);
return size;
Int_t i,k;
fNelems = fNrows*fNcols;
Short_t * buf = new Short_t[fNelems];
+ memset(buf,0,fNelems*sizeof(Short_t)); //MI change - 4.12.2000
fIndex->Set(fNcols);
for (i =0,k=0 ;i<fNcols;i++,k+=fNrows) (*fIndex)[i]=k;
Int_t col=0;
}
fElements->Adopt(fNelems,buf);
}
+
void AliDigits::CompresBuffer1()
{
//
//compres buffer according algorithm 1
//
- AliArrayS buf; //lets have the nearly the "worst case"
+ TArrayS buf; //lets have the nearly the "worst case"
buf.Set(fNelems);
- AliArrayI index;
+ TArrayI index;
index.Set(fNcols);
Int_t icurrent=-1;
Int_t izero;
+ Short_t * cbuff = fElements->GetArray(); //MI change
+
for (Int_t col = 0; col<fNcols; col++){
index[col]=icurrent+1;//set collumn pointer
izero = 0; //reset zer counter at the begining of the column
for (Int_t row = 0; row< fNrows;row++){
//if under threshold
- if (GetDigitFast(row,col)<=fThreshold) izero++;
+ //if (GetDigitFast(row,col)<=fThreshold) izero++;
+ if (*cbuff<=fThreshold) izero++;
+
else{
if (izero>0) {
//if we have currently izero count under threshold
icurrent++;
- if (icurrent>=buf.fN) buf.Expand(icurrent*2);
+ if (icurrent>=buf.fN) buf.Set(icurrent*2);
buf[icurrent]= -izero; //write how many under zero
izero = 0;
} //end of reseting izero
icurrent++;
- if (icurrent>=buf.fN) buf.Expand(icurrent*2);
- buf[icurrent] = GetDigitFast(row,col);
- }//if signal bigger then threshold
+ if (icurrent>=buf.fN) buf.Set(icurrent*2);
+ //buf[icurrent] = GetDigitFast(row,col);
+ buf[icurrent] = *cbuff;
+ }//if signal bigger then threshold
+ cbuff++;
} //end of loop over rows
if (izero>0) {
icurrent++;
- if (icurrent>=buf.fN) buf.Expand(icurrent*2);
+ if (icurrent>=buf.fN) buf.Set(icurrent*2);
buf[icurrent]= -izero; //write how many under zero
}
}//end of lopping over digits
- buf.Expand(icurrent+1);
+ buf.Set(icurrent+1);
(*fElements)=buf;
fNelems = fElements->fN;
fBufType = 1;
fCurrentCol = -1;
fCurrentIndex = -1;
Int_t i;
- for (i=0; (( i<fNelems) && (fElements->At(i)<=fThreshold));i++)
+ for (i=0; (( i<fNelems) && (fElements->At(i)<=fThreshold));i++) {} //MI1211
if (i == fNelems) return kFALSE;
fCurrentCol =i/fNrows;
fCurrentRow =i%fNrows;
//
if (fCurrentIndex<0) return kFALSE; // if we didn't adjust first
Int_t i;
- for (i=fCurrentIndex+1; ( (i<fNelems) && (fElements->At(i)<=fThreshold) ) ;i++);
+ for (i=fCurrentIndex+1; ( (i<fNelems) && (fElements->At(i)<=fThreshold) ) ;i++) {}
if (i >= fNelems) {
fCurrentIndex = -1;
return kFALSE;
if (fElements->At(i)>fThreshold) break;
}
fCurrentIndex = i;
- if (fCurrentIndex>=0) return kTRUE;
+ if (fCurrentIndex>=0&&i<fNelems) return kTRUE;
fCurrentRow =-1;
fCurrentCol =-1;
return kFALSE;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff