////////////////////////////////////////////////////////
#include "AliTRDarrayADC.h"
-#include "Cal/AliTRDCalPadStatus.h"
+#include "Cal/AliTRDCalPadStatus.h"
+#include "AliTRDfeeParam.h"
+#include "AliTRDSignalIndex.h"
+#include "AliLog.h"
ClassImp(AliTRDarrayADC)
+Short_t *AliTRDarrayADC::fgLutPadNumbering = 0x0;
+
//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC()
:TObject()
,fNdet(0)
,fNrow(0)
,fNcol(0)
+ ,fNumberOfChannels(0)
,fNtime(0)
,fNAdim(0)
,fADC(0)
// AliTRDarrayADC default constructor
//
+ CreateLut();
+
}
//____________________________________________________________________________________
,fNdet(0)
,fNrow(0)
,fNcol(0)
+ ,fNumberOfChannels(0)
,fNtime(0)
,fNAdim(0)
,fADC(0)
// AliTRDarrayADC constructor
//
+ CreateLut();
Allocate(nrow,ncol,ntime);
}
//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
- :TObject()
+ :TObject(b)
,fNdet(b.fNdet)
,fNrow(b.fNrow)
,fNcol(b.fNcol)
+ ,fNumberOfChannels(b.fNumberOfChannels)
,fNtime(b.fNtime)
,fNAdim(b.fNAdim)
- ,fADC(0)
+ ,fADC(0)
{
//
// AliTRDarrayADC copy constructor
//
fADC = new Short_t[fNAdim];
- for(Int_t i=0; i<fNAdim; i++)
- {
- fADC[i]=b.fADC[i];
- }
+ memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
}
// AliTRDarrayADC destructor
//
- if(fADC)
- {
- delete [] fADC;
- fADC=0;
- }
+ delete [] fADC;
+ fADC=0;
}
{
return *this;
}
-
if(fADC)
{
delete [] fADC;
}
+ TObject::operator=(b);
fNdet=b.fNdet;
fNrow=b.fNrow;
fNcol=b.fNcol;
+ fNumberOfChannels = b.fNumberOfChannels;
fNtime=b.fNtime;
fNAdim=b.fNAdim;
fADC = new Short_t[fNAdim];
- for(Int_t i=0;i<fNAdim;i++)
- {
- fADC[i]=b.fADC[i];
- }
+ memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
+
return *this;
}
{
//
// Allocate memory for an AliTRDarrayADC array with dimensions
- // Row*Col*Time
+ // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
//
fNrow=nrow;
fNcol=ncol;
fNtime=ntime;
- fNAdim=nrow*ncol*ntime;
+ Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm();
+ Int_t padspermcm = AliTRDfeeParam::GetNcolMcm();
+ Int_t numberofmcms = fNcol/padspermcm;
+ fNumberOfChannels = numberofmcms*adcchannelspermcm;
+ fNAdim=nrow*fNumberOfChannels*ntime;
if(fADC)
{
}
fADC = new Short_t[fNAdim];
- for(Int_t a=0; a<fNAdim; a++)
- {
- fADC[a]=0;
- }
+ memset(fADC,0,sizeof(Short_t)*fNAdim);
}
//____________________________________________________________________________________
-Short_t AliTRDarrayADC::GetDataB(Int_t row, Int_t col, Int_t time) const
+Short_t AliTRDarrayADC::GetDataBits(Int_t row, Int_t col, Int_t time) const
{
//
// Get the ADC value for a given position: row, col, time
// Taking bit masking into account
//
- // Adapted from code of the class AliTRDdataArrayDigits
+ // Adapted from code of the class AliTRDclusterizer
//
- Short_t tempval = fADC[(row*fNcol+col)*fNtime+time];
+ Short_t tempval = GetData(row,col,time);
// Be aware of manipulations introduced by pad masking in the RawReader
// Only output the manipulated Value
CLRBIT(tempval, 10);
// Bridged Right Masking 8
// Not Connected Masking Digits
//
- // Adapted from code of the class AliTRDdataArrayDigits
+ // Adapted from code of the class AliTRDclusterizer
//
UChar_t padstatus = 0;
// Bridged Left masking: Bit 11(0), Bit 12(1)
// Bridged Right masking: Bit 11(1), Bit 12(1)
//
- // Adapted from code of the class AliTRDdataArrayDigits
+ // Adapted from code of the class AliTRDclusterizer
//
Short_t signal = GetData(row,col,time);
SETBIT(signal, 10);
SETBIT(signal, 11);
SETBIT(signal, 12);
+ break;
default:
CLRBIT(signal, 10);
CLRBIT(signal, 11);
//
// Checks if the pad has any masking as corrupted (Bit 10 in signal set)
//
- // Adapted from code of the class AliTRDdataArrayDigits
+ // Adapted from code of the class AliTRDclusterizer
//
Short_t signal = GetData(row,col,time);
// Compress the array
//
+ if(fNAdim!=fNrow*fNumberOfChannels*fNtime)
+ {
+ AliDebug(1,"The ADC array is already compressed");
+ return;
+ }
+
Int_t counter=0;
Int_t newDim=0;
Int_t j;
Int_t l;
Int_t r=0;
Int_t s=0;
- Int_t *longm;
- longm = new Int_t[fNAdim];
- Int_t *longz;
- longz = new Int_t[fNAdim];
Int_t k=0;
- for(Int_t i=0; i<fNAdim;i++)
- {
- longz[i]=0;
- longm[i]=0;
- }
- for(Int_t i=0;i<fNAdim; i++)
+ Int_t *longm = new Int_t[fNAdim];
+ Int_t *longz = new Int_t[fNAdim];
+
+ if(longz && longm && fADC)
{
- j=0;
- if(fADC[i]==-1)
- {
- for(k=i;k<fNAdim;k++)
+
+ memset(longz,0,sizeof(Int_t)*fNAdim);
+ memset(longm,0,sizeof(Int_t)*fNAdim);
+
+ for(Int_t i=0;i<fNAdim; i++)
+ {
+ j=0;
+ if(fADC[i]==-1)
{
- if((fADC[k]==-1)&&(j<16000))
- {
- j=j+1;
- longm[r]=j;
- }
- else
- {
- break;
- }
+ for(k=i;k<fNAdim;k++)
+ {
+ if((fADC[k]==-1)&&(j<16000))
+ {
+ j=j+1;
+ longm[r]=j;
+ }
+ else
+ {
+ break;
+ }
+ }
+ r=r+1;
}
- r=r+1;
- }
- l=16001;
- if(fADC[i]==0)
- {
- for(k=i;k<fNAdim;k++)
+ l=16001;
+ if(fADC[i]==0)
{
- if((fADC[k]==0)&&(l<32767))
- {
- l=l+1;
- longz[s]=l;
- }
- else
- {
- break;
- }
+ for(k=i;k<fNAdim;k++)
+ {
+ if((fADC[k]==0)&&(l<32767))
+ {
+ l=l+1;
+ longz[s]=l;
+ }
+ else
+ {
+ break;
+ }
+ }
+ s=s+1;
}
- s=s+1;
- }
- if(fADC[i]>0)
- {
- i=i+1;
- }
- i=i+j+(l-16001-1);
- }
-
- //Calculate the size of the compressed array
- for(Int_t i=0; i<fNAdim;i++)
- {
- if(longm[i]!=0)
- {
- counter=counter+longm[i]-1;
- }
- if(longz[i]!=0)
- {
- counter=counter+(longz[i]-16001)-1;
- }
- }
- newDim = fNAdim-counter; //Dimension of the compressed array
- Short_t* buffer;
- buffer = new Short_t[newDim];
- Int_t counterTwo=0;
-
- //Fill the buffer of the compressed array
- Int_t g=0;
- Int_t h=0;
- for(Int_t i=0; i<newDim; i++)
- {
- if(counterTwo<fNAdim)
- {
- if(fADC[counterTwo]>0)
+ if(fADC[i]>0)
{
- buffer[i]=fADC[counterTwo];
+ i=i+1;
}
- if(fADC[counterTwo]==-1)
+ i=i+j+(l-16001-1);
+ }
+
+ //Calculate the size of the compressed array
+ for(Int_t i=0; i<fNAdim;i++)
+ {
+ if(longm[i]!=0)
{
- buffer[i]=-(longm[g]);
- counterTwo=counterTwo+longm[g]-1;
- g++;
- }
- if(fADC[counterTwo]==0)
+ counter=counter+longm[i]-1;
+ }
+ if(longz[i]!=0)
{
- buffer[i]=-(longz[h]);
- counterTwo=counterTwo+(longz[h]-16001)-1;
- h++;
- }
- counterTwo++;
- }
- }
+ counter=counter+(longz[i]-16001)-1;
+ }
+ }
+
+ Int_t counterTwo=0;
+ newDim = fNAdim-counter; //Dimension of the compressed array
+ Short_t* buffer = new Short_t[newDim];
+
+ if(buffer)
+ {
+
+ //Fill the buffer of the compressed array
+ Int_t g=0;
+ Int_t h=0;
+ for(Int_t i=0; i<newDim; i++)
+ {
+ if(counterTwo<fNAdim)
+ {
+ if(fADC[counterTwo]>0)
+ {
+ buffer[i]=fADC[counterTwo];
+ }
+ if(fADC[counterTwo]==-1)
+ {
+ buffer[i]=-(longm[g]);
+ counterTwo=counterTwo+longm[g]-1;
+ g++;
+ }
+ if(fADC[counterTwo]==0)
+ {
+ buffer[i]=-(longz[h]);
+ counterTwo=counterTwo+(longz[h]-16001)-1;
+ h++;
+ }
+ counterTwo++;
+ }
+ }
+
+ //Copy the buffer
+ delete [] fADC;
+ fADC=0;
+ fADC = new Short_t[newDim];
+ fNAdim = newDim;
+ for(Int_t i=0; i<newDim; i++)
+ {
+ fADC[i] = buffer[i];
+ }
+
+ //Delete auxiliary arrays
+ delete [] buffer;
+ buffer=0;
+ }
- //Copy the buffer
- if(fADC)
- {
- delete [] fADC;
- fADC=0;
- }
- fADC = new Short_t[newDim];
- fNAdim = newDim;
- for(Int_t i=0; i<newDim; i++)
- {
- fADC[i] = buffer[i];
}
- //Delete auxiliary arrays
- if(buffer)
- {
- delete [] buffer;
- buffer=0;
- }
- if(longz)
+ if (longz)
{
delete [] longz;
longz=0;
}
- if(longm)
+ if (longm)
{
delete [] longm;
longm=0;
+
}
}
// Expand the array
//
- //Check if the array has not been already expanded
- Int_t verif=0;
- for(Int_t i=0; i<fNAdim; i++)
+ if (fADC)
{
- if(fADC[i]<-1)
- {
- verif++;
- }
- }
+
+ //Check if the array has not been already expanded
+ Int_t verif=0;
+ for(Int_t i=0; i<fNAdim; i++)
+ {
+ if(fADC[i]<-1)
+ {
+ verif++;
+ }
+ }
- if(verif==0)
- {
- // AliDebug(1,"Nothing to expand");
- return;
- }
+ if(verif==0)
+ {
+ AliDebug(1,"Nothing to expand");
+ return;
+ }
- Int_t *longz;
- longz = new Int_t[fNAdim];
- Int_t *longm;
- longm = new Int_t[fNAdim];
- Int_t dimexp=0;
- //Initialize arrays
- for(Int_t i=0; i<fNAdim;i++)
- {
- longz[i]=0;
- longm[i]=0;
- }
- Int_t r2=0;
- Int_t r3=0;
- for(Int_t i=0; i<fNAdim;i++)
- {
- if((fADC[i]<0)&&(fADC[i]>=-16000))
- {
- longm[r2]=-fADC[i];
- r2++;
- }
- if(fADC[i]<-16000)
- {
- longz[r3]=-fADC[i]-16001;
- r3++;
- }
- }
- //Calculate the new dimensions of the array
- for(Int_t i=0; i<fNAdim;i++)
- {
- if(longm[i]!=0)
- {
- dimexp=dimexp+longm[i]-1;
- }
- if(longz[i]!=0)
- {
- dimexp=dimexp+longz[i]-1;
- }
- }
- dimexp=dimexp+fNAdim;
-
- //Write in the buffer the new array
- Short_t* bufferE;
- bufferE = new Short_t[dimexp];
- Int_t contaexp =0;
- Int_t h=0;
- Int_t l=0;
- for(Int_t i=0; i<dimexp; i++)
- {
- if(fADC[contaexp]>0)
- {
- bufferE[i]=fADC[contaexp];
- }
+ Int_t dimexp=0;
+ Int_t *longz = new Int_t[fNAdim];
+ Int_t *longm = new Int_t[fNAdim];
- if((fADC[contaexp]<0)&&(fADC[contaexp]>=-16000))
- {
- for(Int_t j=0; j<longm[h];j++)
- {
- bufferE[i+j]=-1;
- }
- i=i+longm[h]-1;
- h++;
- }
- if(fADC[contaexp]<-16000)
+ if (longz && longm)
{
- for(Int_t j=0; j<longz[l];j++)
+
+ //Initialize arrays
+ memset(longz,0,sizeof(Int_t)*fNAdim);
+ memset(longm,0,sizeof(Int_t)*fNAdim);
+ Int_t r2=0;
+ Int_t r3=0;
+ for(Int_t i=0; i<fNAdim;i++)
+ {
+ if((fADC[i]<0)&&(fADC[i]>=-16000))
+ {
+ longm[r2]=-fADC[i];
+ r2++;
+ }
+ if(fADC[i]<-16000)
+ {
+ longz[r3]=-fADC[i]-16001;
+ r3++;
+ }
+ }
+
+ //Calculate the new dimensions of the array
+ for(Int_t i=0; i<fNAdim;i++)
+ {
+ if(longm[i]!=0)
+ {
+ dimexp=dimexp+longm[i]-1;
+ }
+ if(longz[i]!=0)
+ {
+ dimexp=dimexp+longz[i]-1;
+ }
+ }
+ dimexp=dimexp+fNAdim;
+
+ //Write in the buffer the new array
+ Int_t contaexp =0;
+ Int_t h=0;
+ Int_t l=0;
+ Short_t* bufferE = new Short_t[dimexp];
+ if(bufferE)
{
- bufferE[i+j]=0;
+ for(Int_t i=0; i<dimexp; i++)
+ {
+ if(fADC[contaexp]>0)
+ {
+ bufferE[i]=fADC[contaexp];
+ }
+ if((fADC[contaexp]<0)&&(fADC[contaexp]>=-16000))
+ {
+ for(Int_t j=0; j<longm[h];j++)
+ {
+ bufferE[i+j]=-1;
+ }
+ i=i+longm[h]-1;
+ h++;
+ }
+ if(fADC[contaexp]<-16000)
+ {
+ for(Int_t j=0; j<longz[l];j++)
+ {
+ bufferE[i+j]=0;
+ }
+ i=i+longz[l]-1;
+ l++;
+ }
+ contaexp++;
+ }
+ //Copy the buffer
+ delete [] fADC;
+ fADC = new Short_t[dimexp];
+ fNAdim = dimexp;
+ for(Int_t i=0; i<dimexp; i++)
+ {
+ fADC[i] = bufferE[i];
+ }
+
+ delete [] bufferE;
+
}
- i=i+longz[l]-1;
- l++;
+
+ //Delete auxiliary arrays
+ delete [] longm;
+ delete [] longz;
+
}
- contaexp++;
- }
- //Copy the buffer
- if(fADC)
- {
- delete [] fADC;
- fADC=0;
- }
- fADC = new Short_t[dimexp];
- fNAdim = dimexp;
- for(Int_t i=0; i<dimexp; i++)
- {
- fADC[i] = bufferE[i];
}
- //Delete auxiliary arrays
- if(bufferE) delete [] bufferE;
- if(longm) delete [] longm;
- if(longz) delete [] longz;
-
}
//____________________________________________________________________________________
void AliTRDarrayADC::DeleteNegatives()
}
}
}
+//________________________________________________________________________________
+void AliTRDarrayADC::Reset()
+{
+ //
+ // Reset the array, the old contents are deleted
+ // The array keeps the same dimensions as before
+ //
+
+ memset(fADC,0,sizeof(Short_t)*fNAdim);
+}
+//________________________________________________________________________________
+void AliTRDarrayADC::ConditionalReset(AliTRDSignalIndex* idx)
+{
+ //
+ // Reset the array, the old contents are deleted
+ // The array keeps the same dimensions as before
+ //
+
+ if(idx->GetNoOfIndexes()>25)
+ memset(fADC,0,sizeof(Short_t)*fNAdim);
+ else
+ {
+ Int_t row, col;
+ while(idx->NextRCIndex(row, col)){
+ Int_t colnumb = fgLutPadNumbering[col];
+ memset(&fADC[(row*fNumberOfChannels+colnumb)*fNtime],0,fNtime);
+ }
+ }
+
+}
+
+//________________________________________________________________________________
+void AliTRDarrayADC::CreateLut()
+{
+ //
+ // Initializes the Look Up Table to relate
+ // pad numbering and mcm channel numbering
+ //
+
+ if(fgLutPadNumbering) return;
+
+ fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
+ memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());
+
+ for(Int_t mcm=0; mcm<8; mcm++)
+ {
+ Int_t lowerlimit=0+mcm*18;
+ Int_t upperlimit=18+mcm*18;
+ Int_t shiftposition = 1+3*mcm;
+ for(Int_t index=lowerlimit;index<upperlimit;index++)
+ {
+ fgLutPadNumbering[index]=index+shiftposition;
+ }
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff