#include "AliTRDarrayADC.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)
{
CreateLut();
}
AliTRDarrayADC::AliTRDarrayADC(Int_t nrow, Int_t ncol, Int_t ntime)
:TObject()
,fNdet(0)
,fNrow(0)
,fNcol(0)
,fNumberOfChannels(0)
,fNtime(0)
,fNAdim(0)
,fADC(0)
{
CreateLut();
Allocate(nrow,ncol,ntime);
}
AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
:TObject(b)
,fNdet(b.fNdet)
,fNrow(b.fNrow)
,fNcol(b.fNcol)
,fNumberOfChannels(b.fNumberOfChannels)
,fNtime(b.fNtime)
,fNAdim(b.fNAdim)
,fADC(0)
{
fADC = new Short_t[fNAdim];
memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
}
AliTRDarrayADC::~AliTRDarrayADC()
{
delete [] fADC;
fADC=0;
}
AliTRDarrayADC &AliTRDarrayADC::operator=(const AliTRDarrayADC &b)
{
if(this==&b)
{
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];
memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
return *this;
}
void AliTRDarrayADC::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
{
fNrow=nrow;
fNcol=ncol;
fNtime=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)
{
delete [] fADC;
}
fADC = new Short_t[fNAdim];
memset(fADC,0,sizeof(Short_t)*fNAdim);
}
Short_t AliTRDarrayADC::GetDataBits(Int_t row, Int_t col, Int_t time) const
{
Short_t tempval = GetData(row,col,time);
CLRBIT(tempval, 10);
CLRBIT(tempval, 11);
CLRBIT(tempval, 12);
return tempval;
}
UChar_t AliTRDarrayADC::GetPadStatus(Int_t row, Int_t col, Int_t time) const
{
UChar_t padstatus = 0;
Short_t signal = GetData(row,col,time);
if(signal > 0 && TESTBIT(signal, 10)){
if(TESTBIT(signal, 11))
if(TESTBIT(signal, 12))
padstatus = AliTRDCalPadStatus::kPadBridgedRight;
else
padstatus = AliTRDCalPadStatus::kNotConnected;
else
if(TESTBIT(signal, 12))
padstatus = AliTRDCalPadStatus::kPadBridgedLeft;
else
padstatus = AliTRDCalPadStatus::kMasked;
}
return padstatus;
}
void AliTRDarrayADC::SetPadStatus(Int_t row, Int_t col, Int_t time, UChar_t status)
{
Short_t signal = GetData(row,col,time);
if(signal > 0)
{
switch(status)
{
case AliTRDCalPadStatus::kMasked:
SETBIT(signal, 10);
CLRBIT(signal, 11);
CLRBIT(signal, 12);
break;
case AliTRDCalPadStatus::kNotConnected:
SETBIT(signal, 10);
SETBIT(signal, 11);
CLRBIT(signal, 12);
break;
case AliTRDCalPadStatus::kPadBridgedLeft:
SETBIT(signal, 10);
CLRBIT(signal, 11);
SETBIT(signal, 12);
break;
case AliTRDCalPadStatus::kPadBridgedRight:
SETBIT(signal, 10);
SETBIT(signal, 11);
SETBIT(signal, 12);
break;
default:
CLRBIT(signal, 10);
CLRBIT(signal, 11);
CLRBIT(signal, 12);
}
SetData(row, col, time, signal);
}
}
Bool_t AliTRDarrayADC::IsPadCorrupted(Int_t row, Int_t col, Int_t time)
{
Short_t signal = GetData(row,col,time);
return (signal > 0 && TESTBIT(signal, 10)) ? kTRUE : kFALSE;
}
void AliTRDarrayADC::Compress()
{
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 k=0;
Int_t *longm = new Int_t[fNAdim];
Int_t *longz = new Int_t[fNAdim];
if(longz && longm && fADC)
{
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)
{
for(k=i;k<fNAdim;k++)
{
if((fADC[k]==-1)&&(j<16000))
{
j=j+1;
longm[r]=j;
}
else
{
break;
}
}
r=r+1;
}
l=16001;
if(fADC[i]==0)
{
for(k=i;k<fNAdim;k++)
{
if((fADC[k]==0)&&(l<32767))
{
l=l+1;
longz[s]=l;
}
else
{
break;
}
}
s=s+1;
}
if(fADC[i]>0)
{
i=i+1;
}
i=i+j+(l-16001-1);
}
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;
}
}
Int_t counterTwo=0;
newDim = fNAdim-counter;
Short_t* buffer = new Short_t[newDim];
if(buffer)
{
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++;
}
}
delete [] fADC;
fADC=0;
fADC = new Short_t[newDim];
fNAdim = newDim;
for(Int_t i=0; i<newDim; i++)
{
fADC[i] = buffer[i];
}
delete [] buffer;
buffer=0;
}
}
if (longz)
{
delete [] longz;
longz=0;
}
if (longm)
{
delete [] longm;
longm=0;
}
}
void AliTRDarrayADC::Expand()
{
if (fADC)
{
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;
}
Int_t dimexp=0;
Int_t *longz = new Int_t[fNAdim];
Int_t *longm = new Int_t[fNAdim];
if (longz && longm)
{
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++;
}
}
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;
Int_t contaexp =0;
Int_t h=0;
Int_t l=0;
Short_t* bufferE = new Short_t[dimexp];
if(bufferE)
{
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++;
}
delete [] fADC;
fADC = new Short_t[dimexp];
fNAdim = dimexp;
for(Int_t i=0; i<dimexp; i++)
{
fADC[i] = bufferE[i];
}
delete [] bufferE;
}
delete [] longm;
delete [] longz;
}
}
}
void AliTRDarrayADC::DeleteNegatives()
{
for(Int_t a=0; a<fNAdim; a++)
{
if(fADC[a]==-1)
{
fADC[a]=0;
}
}
}
void AliTRDarrayADC::Reset()
{
memset(fADC,0,sizeof(Short_t)*fNAdim);
}
void AliTRDarrayADC::ConditionalReset(AliTRDSignalIndex* idx)
{
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()
{
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;
}
}
}