#include "Riostream.h"
#include <TF1.h>
#include <TFile.h>
#include <TGraph.h>
#include <TH1F.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include <TRandom.h>
#include <TTree.h>
#include <TTreeStream.h>
#include "TSystem.h"
#include "TClass.h"
#include "AliDigits.h"
#include "AliLoader.h"
#include "AliLog.h"
#include "AliMathBase.h"
#include "AliRawEventHeaderBase.h"
#include "AliRawReader.h"
#include "AliRunLoader.h"
#include "AliSimDigits.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
#include "AliTPCClustersRow.h"
#include "AliTPCParam.h"
#include "AliTPCRawStreamV3.h"
#include "AliTPCRecoParam.h"
#include "AliTPCReconstructor.h"
#include "AliTPCcalibDB.h"
#include "AliTPCclusterInfo.h"
#include "AliTPCclusterMI.h"
#include "AliTPCTransform.h"
#include "AliTPCclusterer.h"
using std::cerr;
using std::endl;
ClassImp(AliTPCclusterer)
AliTPCclusterer::AliTPCclusterer(const AliTPCParam* par, const AliTPCRecoParam * recoParam):
fBins(0),
fSigBins(0),
fNSigBins(0),
fLoop(0),
fMaxBin(0),
fMaxTime(1006),
fMaxPad(0),
fSector(-1),
fRow(-1),
fSign(0),
fRx(0),
fPadWidth(0),
fPadLength(0),
fZWidth(0),
fPedSubtraction(kFALSE),
fEventHeader(0),
fTimeStamp(0),
fEventType(0),
fInput(0),
fOutput(0),
fOutputArray(0),
fOutputClonesArray(0),
fRowCl(0),
fRowDig(0),
fParam(0),
fNcluster(0),
fNclusters(0),
fDebugStreamer(0),
fRecoParam(0),
fBDumpSignal(kFALSE),
fBClonesArray(kFALSE),
fUseHLTClusters(4),
fAllBins(NULL),
fAllSigBins(NULL),
fAllNSigBins(NULL),
fHLTClusterAccess(NULL)
{
fInput =0;
fParam = par;
if (recoParam) {
fRecoParam = recoParam;
}else{
fRecoParam = AliTPCReconstructor::GetRecoParam();
if (!fRecoParam) fRecoParam = AliTPCRecoParam::GetLowFluxParam();
}
if(AliTPCReconstructor::StreamLevel()>0) {
fDebugStreamer = new TTreeSRedirector("TPCsignal.root");
}
fRowCl= new AliTPCClustersRow("AliTPCclusterMI");
AliTPCROC * roc = AliTPCROC::Instance();
Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
Int_t nPadsMax = roc->GetNPads(roc->GetNSector()-1,nRowsMax-1);
fAllBins = new Float_t*[nRowsMax];
fAllSigBins = new Int_t*[nRowsMax];
fAllNSigBins = new Int_t[nRowsMax];
for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
Int_t maxBin = fMaxTime*(nPadsMax+6);
fAllBins[iRow] = new Float_t[maxBin];
memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
fAllSigBins[iRow] = new Int_t[maxBin];
fAllNSigBins[iRow]=0;
}
}
AliTPCclusterer::~AliTPCclusterer(){
if (fDebugStreamer) delete fDebugStreamer;
if (fOutputArray){
delete fOutputArray;
}
if (fOutputClonesArray){
fOutputClonesArray->Delete();
delete fOutputClonesArray;
}
if (fRowCl) {
fRowCl->GetArray()->Delete();
delete fRowCl;
}
AliTPCROC * roc = AliTPCROC::Instance();
Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
delete [] fAllBins[iRow];
delete [] fAllSigBins[iRow];
}
delete [] fAllBins;
delete [] fAllSigBins;
delete [] fAllNSigBins;
if (fHLTClusterAccess) delete fHLTClusterAccess;
}
void AliTPCclusterer::SetInput(TTree * tree)
{
fInput = tree;
if (!fInput->GetBranch("Segment")){
cerr<<"AliTPC::Digits2Clusters(): no porper input tree !\n";
fInput=0;
return;
}
}
void AliTPCclusterer::SetOutput(TTree * tree)
{
if (!tree) return;
fOutput= tree;
AliTPCClustersRow clrow("AliTPCclusterMI");
AliTPCClustersRow *pclrow=&clrow;
fOutput->Branch("Segment","AliTPCClustersRow",&pclrow,32000,200);
}
void AliTPCclusterer::FillRow(){
if (fOutput) fOutput->Fill();
if (!fOutput && !fBClonesArray){
if (!fOutputArray) fOutputArray = new TObjArray(fParam->GetNRowsTotal());
if (fRowCl && fRowCl->GetArray()->GetEntriesFast()>0) fOutputArray->AddAt(fRowCl->Clone(), fRowCl->GetID());
}
}
Float_t AliTPCclusterer::GetSigmaY2(Int_t iz){
Float_t z = iz*fParam->GetZWidth()+fParam->GetNTBinsL1()*fParam->GetZWidth();
Float_t sd2 = (z*fParam->GetDiffL()*fParam->GetDiffL())/
(fPadWidth*fPadWidth);
Float_t sres = 0.25;
Float_t res = sd2+sres;
return res;
}
Float_t AliTPCclusterer::GetSigmaZ2(Int_t iz){
Float_t z = iz*fZWidth+fParam->GetNTBinsL1()*fParam->GetZWidth();
Float_t sd2 = (z*fParam->GetDiffL()*fParam->GetDiffL())/(fZWidth*fZWidth);
Float_t angular = fPadLength*(fParam->GetZLength(fSector)-z)/(fRx*fZWidth);
angular*=angular;
angular/=12.;
Float_t sres = fParam->GetZSigma()/fZWidth;
sres *=sres;
Float_t res = angular +sd2+sres;
return res;
}
void AliTPCclusterer::MakeCluster(Int_t k,Int_t max,Float_t *bins, UInt_t ,
AliTPCclusterMI &c)
{
Double_t kVirtualChargeFactor=0.5;
Int_t i0=k/max;
Int_t j0=k%max;
Float_t * matrix[5];
for (Int_t di=-2;di<=2;di++){
matrix[di+2] = &bins[k+di*max];
}
Float_t sigmay2= GetSigmaY2(j0);
Float_t sigmaz2= GetSigmaZ2(j0);
Float_t vmatrix[5][5];
vmatrix[2][2] = matrix[2][0];
c.SetType(0);
c.SetMax((UShort_t)(vmatrix[2][2]));
for (Int_t di =-1;di <=1;di++)
for (Int_t dj =-1;dj <=1;dj++){
Float_t amp = matrix[di+2][dj];
if ( (amp<2) && (fLoop<2)){
Float_t ratio = TMath::Exp(-1.2*TMath::Abs(di)/sigmay2)*TMath::Exp(-1.2*TMath::Abs(dj)/sigmaz2);
amp = ((matrix[2][0]-2)*(matrix[2][0]-2)/(matrix[-di+2][-dj]+2))*ratio;
if (amp>2) amp = 2;
vmatrix[2+di][2+dj]= kVirtualChargeFactor*amp;
vmatrix[2+2*di][2+2*dj]=0;
if ( (di*dj)!=0){
vmatrix[2+2*di][2+dj] =0;
vmatrix[2+di][2+2*dj] =0;
}
continue;
}
if (amp<4){
vmatrix[2+di][2+dj]=amp;
vmatrix[2+2*di][2+2*dj]=0;
if ( (di*dj)!=0){
vmatrix[2+2*di][2+dj] =0;
vmatrix[2+di][2+2*dj] =0;
}
continue;
}
vmatrix[2+di][2+dj]=amp;
vmatrix[2+2*di][2+2*dj]= matrix[2*di+2][2*dj] ;
if ( (di*dj)!=0){
vmatrix[2+2*di][2+dj] = matrix[2*di+2][dj];
vmatrix[2+di][2+2*dj] = matrix[2+di][dj*2];
}
}
Float_t sumw=0;
Float_t sumiw=0;
Float_t sumi2w=0;
Float_t sumjw=0;
Float_t sumj2w=0;
for (Int_t i=-2;i<=2;i++)
for (Int_t j=-2;j<=2;j++){
Float_t amp = vmatrix[i+2][j+2];
sumw += amp;
sumiw += i*amp;
sumi2w += i*i*amp;
sumjw += j*amp;
sumj2w += j*j*amp;
}
Float_t meani = sumiw/sumw;
Float_t mi2 = sumi2w/sumw-meani*meani;
Float_t meanj = sumjw/sumw;
Float_t mj2 = sumj2w/sumw-meanj*meanj;
Float_t ry = mi2/sigmay2;
Float_t rz = mj2/sigmaz2;
if ( ( (ry<0.6) || (rz<0.6) ) && fLoop==2) return;
if ( ((ry <1.2) && (rz<1.2)) || (!fRecoParam->GetDoUnfold())) {
meani +=i0;
meanj +=j0;
c.SetQ(sumw);
c.SetPad(meani-2.5);
c.SetTimeBin(meanj-3);
c.SetSigmaY2(mi2);
c.SetSigmaZ2(mj2);
c.SetType(0);
AddCluster(c,(Float_t*)vmatrix,k);
return;
}
Float_t * matrix2[7];
Float_t dummy[7]={0,0,0,0,0,0};
for (Int_t di=-3;di<=3;di++){
matrix2[di+3] = &bins[k+di*max];
if ((k+di*max)<3) matrix2[di+3] = &dummy[3];
if ((k+di*max)>fMaxBin-3) matrix2[di+3] = &dummy[3];
}
Float_t vmatrix2[5][5];
Float_t sumu;
Float_t overlap;
UnfoldCluster(matrix2,vmatrix2,meani,meanj,sumu,overlap);
meani +=i0;
meanj +=j0;
c.SetQ(sumu);
c.SetPad(meani-2.5);
c.SetTimeBin(meanj-3);
c.SetSigmaY2(mi2);
c.SetSigmaZ2(mj2);
c.SetType(Char_t(overlap)+1);
AddCluster(c,(Float_t*)vmatrix,k);
meani-=i0;
meanj-=j0;
}
void AliTPCclusterer::UnfoldCluster(Float_t * matrix2[7], Float_t recmatrix[5][5], Float_t & meani, Float_t & meanj,
Float_t & sumu, Float_t & overlap )
{
Float_t sum3i[7] = {0,0,0,0,0,0,0};
Float_t sum3j[7] = {0,0,0,0,0,0,0};
for (Int_t k =0;k<7;k++)
for (Int_t l = -1; l<=1;l++){
sum3i[k]+=matrix2[k][l];
sum3j[k]+=matrix2[l+3][k-3];
}
Float_t mratio[3][3]={{1,1,1},{1,1,1},{1,1,1}};
Float_t sum3wi = 0;
Float_t sum3wio = 0;
Float_t sum3iw = 0;
for (Int_t dk=-1;dk<=1;dk++){
sum3wio+=sum3i[dk+3];
if (dk==0){
sum3wi+=sum3i[dk+3];
}
else{
Float_t ratio =1;
if ( ( ((sum3i[dk+3]+3)/(sum3i[3]-3))+1 < (sum3i[2*dk+3]-3)/(sum3i[dk+3]+3))||
(sum3i[dk+3]<=sum3i[2*dk+3] && sum3i[dk+3]>2 )){
Float_t xm2 = sum3i[-dk+3];
Float_t xm1 = sum3i[+3];
Float_t x1 = sum3i[2*dk+3];
Float_t x2 = sum3i[3*dk+3];
Float_t w11 = TMath::Max((Float_t)(4.*xm1-xm2),(Float_t)0.000001);
Float_t w12 = TMath::Max((Float_t)(4 *x1 -x2),(Float_t)0.);
ratio = w11/(w11+w12);
for (Int_t dl=-1;dl<=1;dl++)
mratio[dk+1][dl+1] *= ratio;
}
Float_t amp = sum3i[dk+3]*ratio;
sum3wi+=amp;
sum3iw+= dk*amp;
}
}
meani = sum3iw/sum3wi;
Float_t overlapi = (sum3wio-sum3wi)/sum3wio;
Float_t sum3wj = 0;
Float_t sum3wjo = 0;
Float_t sum3jw = 0;
for (Int_t dk=-1;dk<=1;dk++){
sum3wjo+=sum3j[dk+3];
if (dk==0){
sum3wj+=sum3j[dk+3];
}
else{
Float_t ratio =1;
if ( ( ((sum3j[dk+3]+3)/(sum3j[3]-3))+1 < (sum3j[2*dk+3]-3)/(sum3j[dk+3]+3)) ||
(sum3j[dk+3]<=sum3j[2*dk+3] && sum3j[dk+3]>2)){
Float_t xm2 = sum3j[-dk+3];
Float_t xm1 = sum3j[+3];
Float_t x1 = sum3j[2*dk+3];
Float_t x2 = sum3j[3*dk+3];
Float_t w11 = TMath::Max((Float_t)(4.*xm1-xm2),(Float_t)0.000001);
Float_t w12 = TMath::Max((Float_t)(4 *x1 -x2),(Float_t)0.);
ratio = w11/(w11+w12);
for (Int_t dl=-1;dl<=1;dl++)
mratio[dl+1][dk+1] *= ratio;
}
Float_t amp = sum3j[dk+3]*ratio;
sum3wj+=amp;
sum3jw+= dk*amp;
}
}
meanj = sum3jw/sum3wj;
Float_t overlapj = (sum3wjo-sum3wj)/sum3wjo;
overlap = Int_t(100*TMath::Max(overlapi,overlapj)+3);
sumu = (sum3wj+sum3wi)/2.;
if (overlap ==3) {
for (Int_t di =-2; di<=2;di++)
for (Int_t dj =-2; dj<=2;dj++){
recmatrix[di+2][dj+2] = matrix2[3+di][dj];
}
}
else{
for (Int_t di =-1; di<=1;di++)
for (Int_t dj =-1; dj<=1;dj++){
Float_t ratio =1;
if (mratio[di+1][dj+1]==1){
recmatrix[di+2][dj+2] = matrix2[3+di][dj];
if (TMath::Abs(di)+TMath::Abs(dj)>1){
recmatrix[2*di+2][dj+2] = matrix2[3+2*di][dj];
recmatrix[di+2][2*dj+2] = matrix2[3+di][2*dj];
}
recmatrix[2*di+2][2*dj+2] = matrix2[3+2*di][2*dj];
}
else
{
recmatrix[di+2][dj+2] = mratio[di+1][dj+1]* matrix2[3+di][dj];
if (TMath::Abs(di)+TMath::Abs(dj)>1){
ratio = TMath::Min((Float_t)(recmatrix[di+2][dj+2]/(matrix2[3+0*di][1*dj]+1)),(Float_t)1.);
recmatrix[2*di+2][dj+2] = ratio*recmatrix[di+2][dj+2];
ratio = TMath::Min((Float_t)(recmatrix[di+2][dj+2]/(matrix2[3+1*di][0*dj]+1)),(Float_t)1.);
recmatrix[di+2][2*dj+2] = ratio*recmatrix[di+2][dj+2];
}
else{
ratio = recmatrix[di+2][dj+2]/matrix2[3][0];
recmatrix[2*di+2][2*dj+2] = ratio*recmatrix[di+2][dj+2];
}
}
}
}
}
Float_t AliTPCclusterer::FitMax(Float_t vmatrix[5][5], Float_t y, Float_t z, Float_t sigmay, Float_t sigmaz)
{
Float_t sumteor= 0;
Float_t sumamp = 0;
for (Int_t di = -1;di<=1;di++)
for (Int_t dj = -1;dj<=1;dj++){
if (vmatrix[2+di][2+dj]>2){
Float_t teor = TMath::Gaus(di,y,sigmay*1.2)*TMath::Gaus(dj,z,sigmaz*1.2);
sumteor += teor*vmatrix[2+di][2+dj];
sumamp += vmatrix[2+di][2+dj]*vmatrix[2+di][2+dj];
}
}
Float_t max = sumamp/sumteor;
return max;
}
void AliTPCclusterer::AddCluster(AliTPCclusterMI &c, Float_t * , Int_t ){
Float_t meani = c.GetPad();
Float_t meanj = c.GetTimeBin();
Int_t ki = TMath::Nint(meani);
if (ki<0) ki=0;
if (ki>=fMaxPad) ki = fMaxPad-1;
Int_t kj = TMath::Nint(meanj);
if (kj<0) kj=0;
if (kj>=fMaxTime-3) kj=fMaxTime-4;
if (fRowDig) {
c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,0)-2,0);
c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,1)-2,1);
c.SetLabel(fRowDig->GetTrackIDFast(kj,ki,2)-2,2);
}
c.SetRow(fRow);
c.SetDetector(fSector);
Float_t s2 = c.GetSigmaY2();
Float_t w=fParam->GetPadPitchWidth(fSector);
c.SetSigmaY2(s2*w*w);
s2 = c.GetSigmaZ2();
c.SetSigmaZ2(s2*fZWidth*fZWidth);
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
if (!transform) {
AliFatal("Tranformations not in calibDB");
return;
}
transform->SetCurrentRecoParam((AliTPCRecoParam*)fRecoParam);
Double_t x[3]={static_cast<Double_t>(c.GetRow()),static_cast<Double_t>(c.GetPad()),static_cast<Double_t>(c.GetTimeBin())};
Int_t i[1]={fSector};
transform->Transform(x,i,0,1);
c.SetX(x[0]);
c.SetY(x[1]);
c.SetZ(x[2]);
if (ki<=1 || ki>=fMaxPad-1 || kj==1 || kj==fMaxTime-2) {
c.SetType(-(c.GetType()+3));
}
if (fLoop==2) c.SetType(100);
TClonesArray * arr = 0;
AliTPCclusterMI * cl = 0;
if(fBClonesArray==kFALSE) {
arr = fRowCl->GetArray();
cl = new ((*arr)[fNcluster]) AliTPCclusterMI(c);
} else {
cl = new ((*fOutputClonesArray)[fNclusters+fNcluster]) AliTPCclusterMI(c);
}
if (!fRecoParam->DumpSignal()) {
cl->SetInfo(0);
}
const Int_t kClusterStream=128;
if ( (AliTPCReconstructor::StreamLevel()&kClusterStream)==kClusterStream) {
Float_t xyz[3];
cl->GetGlobalXYZ(xyz);
(*fDebugStreamer)<<"Clusters"<<
"Cl.="<<cl<<
"gx="<<xyz[0]<<
"gy="<<xyz[1]<<
"gz="<<xyz[2]<<
"\n";
}
fNcluster++;
}
void AliTPCclusterer::Digits2Clusters()
{
if (!fInput) {
Error("Digits2Clusters", "input tree not initialised");
return;
}
fRecoParam = AliTPCReconstructor::GetRecoParam();
if (!fRecoParam){
AliFatal("Can not get the reconstruction parameters");
}
if(AliTPCReconstructor::StreamLevel()>5) {
AliInfo("Parameter Dumps");
fParam->Dump();
fRecoParam->Dump();
}
fRowDig = NULL;
if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
AliInfo("Using HLT clusters for TPC off-line reconstruction");
fZWidth = fParam->GetZWidth();
Int_t iResult = ReadHLTClusters();
if (iResult >= 0 && fNclusters > 0)
return;
if (iResult < 0 || fNclusters == 0) {
if (fUseHLTClusters == 3) {
AliError("No HLT clusters present, but requested.");
return;
}
else {
AliInfo("Now trying to read from TPC RAW");
}
}
else {
AliWarning("Some problem while unpacking of HLT clusters.");
return;
}
}
AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance()->GetPadGainFactor();
AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
AliSimDigits digarr, *dummy=&digarr;
fRowDig = dummy;
fInput->GetBranch("Segment")->SetAddress(&dummy);
Stat_t nentries = fInput->GetEntries();
fMaxTime=fRecoParam->GetLastBin()+6;
Int_t nclusters = 0;
for (Int_t n=0; n<nentries; n++) {
fInput->GetEvent(n);
if (!fParam->AdjustSectorRow(digarr.GetID(),fSector,fRow)) {
cerr<<"AliTPC warning: invalid segment ID ! "<<digarr.GetID()<<endl;
continue;
}
Int_t row = fRow;
AliTPCCalROC * gainROC = gainTPC->GetCalROC(fSector);
AliTPCCalROC * noiseROC = noiseTPC->GetCalROC(fSector);
fRowCl->SetID(digarr.GetID());
if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
fRx=fParam->GetPadRowRadii(fSector,row);
const Int_t kNIS=fParam->GetNInnerSector(), kNOS=fParam->GetNOuterSector();
fZWidth = fParam->GetZWidth();
if (fSector < kNIS) {
fMaxPad = fParam->GetNPadsLow(row);
fSign = (fSector < kNIS/2) ? 1 : -1;
fPadLength = fParam->GetPadPitchLength(fSector,row);
fPadWidth = fParam->GetPadPitchWidth();
} else {
fMaxPad = fParam->GetNPadsUp(row);
fSign = ((fSector-kNIS) < kNOS/2) ? 1 : -1;
fPadLength = fParam->GetPadPitchLength(fSector,row);
fPadWidth = fParam->GetPadPitchWidth();
}
fMaxBin=fMaxTime*(fMaxPad+6);
fBins =new Float_t[fMaxBin];
fSigBins =new Int_t[fMaxBin];
fNSigBins = 0;
memset(fBins,0,sizeof(Float_t)*fMaxBin);
if (digarr.First())
do {
Float_t dig=digarr.CurrentDigit();
if (dig<=fParam->GetZeroSup()) continue;
Int_t j=digarr.CurrentRow()+3, i=digarr.CurrentColumn()+3;
Float_t gain = gainROC->GetValue(row,digarr.CurrentColumn());
Int_t bin = i*fMaxTime+j;
if (gain>0){
fBins[bin]=dig/gain;
}else{
fBins[bin]=0;
}
fSigBins[fNSigBins++]=bin;
} while (digarr.Next());
digarr.ExpandTrackBuffer();
FindClusters(noiseROC);
FillRow();
fRowCl->GetArray()->Clear("C");
nclusters+=fNcluster;
delete[] fBins;
delete[] fSigBins;
}
Info("Digits2Clusters", "Number of found clusters : %d", nclusters);
if (fUseHLTClusters == 2 && nclusters == 0) {
AliInfo("No clusters from TPC Raw data, now trying to read HLT clusters.");
fZWidth = fParam->GetZWidth();
ReadHLTClusters();
}
}
void AliTPCclusterer::ProcessSectorData(){
AliTPCCalPad * pedestalTPC = AliTPCcalibDB::Instance()->GetPedestals();
AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
AliTPCCalROC * pedestalROC = pedestalTPC->GetCalROC(fSector);
AliTPCCalROC * noiseROC = noiseTPC->GetCalROC(fSector);
if (!noiseROC ||!pedestalROC ) {
AliError(Form("Missing calibration per sector\t%d\n",fSector));
return;
}
Int_t nRows=fParam->GetNRow(fSector);
Bool_t calcPedestal = fRecoParam->GetCalcPedestal();
Int_t zeroSup = fParam->GetZeroSup();
if (kFALSE ) {
for (Int_t iRow = 0; iRow < nRows; iRow++) {
Int_t maxPad = fParam->GetNPads(fSector, iRow);
for (Int_t iPad = 3; iPad < maxPad + 3; iPad++) {
if (!calcPedestal && fAllBins[iRow][iPad*fMaxTime+0]<50) continue;
if (fAllBins[iRow][iPad*fMaxTime+0] <1 ) continue;
Float_t *p = &fAllBins[iRow][iPad*fMaxTime+3];
Int_t id[3] = {fSector, iRow, iPad-3};
Double_t rmsCalib= noiseROC->GetValue(iRow,iPad-3);
Double_t pedestalCalib = pedestalROC->GetValue(iRow,iPad-3);
Double_t rmsEvent = rmsCalib;
Double_t pedestalEvent = pedestalCalib;
ProcesSignal(p, fMaxTime, id, rmsEvent, pedestalEvent);
if (rmsEvent<rmsCalib) rmsEvent = rmsCalib;
if (TMath::Abs(pedestalEvent-pedestalCalib)<1.0) pedestalEvent = pedestalCalib;
for (Int_t iTimeBin = 0; iTimeBin < fMaxTime; iTimeBin++) {
Int_t bin = iPad*fMaxTime+iTimeBin;
fAllBins[iRow][bin] -= pedestalEvent;
if (iTimeBin < fRecoParam->GetFirstBin())
fAllBins[iRow][bin] = 0;
if (iTimeBin > fRecoParam->GetLastBin())
fAllBins[iRow][bin] = 0;
if (fAllBins[iRow][iPad*fMaxTime+iTimeBin] < zeroSup)
fAllBins[iRow][bin] = 0;
if (fAllBins[iRow][bin] < 3.0*rmsEvent)
fAllBins[iRow][bin] = 0;
if (fAllBins[iRow][bin]) fAllSigBins[iRow][fAllNSigBins[iRow]++] = bin;
}
}
}
}
if (AliTPCReconstructor::StreamLevel()>5) {
for (Int_t iRow = 0; iRow < nRows; iRow++) {
Int_t maxPad = fParam->GetNPads(fSector,iRow);
for (Int_t iPad = 3; iPad < maxPad + 3; iPad++) {
for (Int_t iTimeBin = 0; iTimeBin < fMaxTime; iTimeBin++) {
Int_t bin = iPad*fMaxTime+iTimeBin;
Float_t signal = fAllBins[iRow][bin];
if (AliTPCReconstructor::StreamLevel()>3 && signal>3) {
Double_t x[]={static_cast<Double_t>(iRow),static_cast<Double_t>(iPad-3),static_cast<Double_t>(iTimeBin-3)};
Int_t i[]={fSector};
AliTPCTransform trafo;
trafo.Transform(x,i,0,1);
Double_t gx[3]={x[0],x[1],x[2]};
trafo.RotatedGlobal2Global(fSector,gx);
Int_t rowsigBins = fAllNSigBins[iRow];
Int_t first=fAllSigBins[iRow][0];
Int_t last= 0;
if (AliTPCReconstructor::StreamLevel()>5) {
(*fDebugStreamer)<<"Digits"<<
"sec="<<fSector<<
"row="<<iRow<<
"pad="<<iPad<<
"time="<<iTimeBin<<
"sig="<<signal<<
"x="<<x[0]<<
"y="<<x[1]<<
"z="<<x[2]<<
"gx="<<gx[0]<<
"gy="<<gx[1]<<
"gz="<<gx[2]<<
"rowsigBins="<<rowsigBins<<
"first="<<first<<
"last="<<last<<
"\n";
}
}
}
}
}
}
for (fRow = 0; fRow < nRows; fRow++) {
fRowCl->SetID(fParam->GetIndex(fSector, fRow));
if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
fRx = fParam->GetPadRowRadii(fSector, fRow);
fPadLength = fParam->GetPadPitchLength(fSector, fRow);
fPadWidth = fParam->GetPadPitchWidth();
fMaxPad = fParam->GetNPads(fSector,fRow);
fMaxBin = fMaxTime*(fMaxPad+6);
fBins = fAllBins[fRow];
fSigBins = fAllSigBins[fRow];
fNSigBins = fAllNSigBins[fRow];
FindClusters(noiseROC);
FillRow();
if(fBClonesArray == kFALSE) fRowCl->GetArray()->Clear("C");
fNclusters += fNcluster;
}
}
void AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
{
fRecoParam = AliTPCReconstructor::GetRecoParam();
if (!fRecoParam){
AliFatal("Can not get the reconstruction parameters");
}
if(AliTPCReconstructor::StreamLevel()>5) {
AliInfo("Parameter Dumps");
fParam->Dump();
fRecoParam->Dump();
}
fRowDig = NULL;
fEventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
if (fEventHeader){
fTimeStamp = fEventHeader->Get("Timestamp");
fEventType = fEventHeader->Get("Type");
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
transform->SetCurrentTimeStamp(fTimeStamp);
transform->SetCurrentRun(rawReader->GetRunNumber());
}
if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
AliInfo("Using HLT clusters for TPC off-line reconstruction");
fZWidth = fParam->GetZWidth();
Int_t iResult = ReadHLTClusters();
if (iResult >= 0 && fNclusters > 0)
return;
if (iResult < 0 || fNclusters == 0) {
if (fUseHLTClusters == 3) {
AliError("No HLT clusters present, but requested.");
return;
}
else {
AliInfo("Now trying to read TPC RAW");
}
}
else {
AliWarning("Some problem while unpacking of HLT clusters.");
return;
}
}
AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance()->GetPadGainFactor();
AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();
AliTPCRawStreamV3 input(rawReader,(AliAltroMapping**)mapping);
if(fBClonesArray && !fOutputClonesArray) fOutputClonesArray = new TClonesArray("AliTPCclusterMI",1000);
fNclusters = 0;
fMaxTime = fRecoParam->GetLastBin() + 6;
fZWidth = fParam->GetZWidth();
Int_t zeroSup = fParam->GetZeroSup();
AliTPCROC * roc = AliTPCROC::Instance();
Int_t nRowsMax = roc->GetNRows(roc->GetNSector()-1);
Int_t nPadsMax = roc->GetNPads(roc->GetNSector()-1,nRowsMax-1);
for (Int_t iRow = 0; iRow < nRowsMax; iRow++) {
Int_t maxBin = fMaxTime*(nPadsMax+6);
memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
fAllNSigBins[iRow]=0;
}
rawReader->Reset();
Int_t digCounter=0;
const Int_t kNIS = fParam->GetNInnerSector();
const Int_t kNOS = fParam->GetNOuterSector();
const Int_t kNS = kNIS + kNOS;
for(fSector = 0; fSector < kNS; fSector++) {
Int_t nRows = 0;
Int_t nDDLs = 0, indexDDL = 0;
if (fSector < kNIS) {
nRows = fParam->GetNRowLow();
fSign = (fSector < kNIS/2) ? 1 : -1;
nDDLs = 2;
indexDDL = fSector * 2;
}
else {
nRows = fParam->GetNRowUp();
fSign = ((fSector-kNIS) < kNOS/2) ? 1 : -1;
nDDLs = 4;
indexDDL = (fSector-kNIS) * 4 + kNIS * 2;
}
rawReader->Reset();
rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);
while (input.NextDDL()){
if (input.GetSector() != fSector)
AliFatal(Form("Sector index mismatch ! Expected (%d), but got (%d) !",fSector,input.GetSector()));
AliTPCCalROC * gainROC = gainTPC->GetCalROC(fSector);
Bool_t calcPedestal = fRecoParam->GetCalcPedestal();
Float_t gain =1;
while ( input.NextChannel() ) {
Int_t iRow = input.GetRow();
if (iRow < 0){
continue;
}
if (iRow >= nRows){
AliError(Form("Pad-row index (%d) outside the range (%d -> %d) !",
iRow, 0, nRows -1));
continue;
}
Int_t iPad = input.GetPad();
if (iPad < 0 || iPad >= nPadsMax) {
AliError(Form("Pad index (%d) outside the range (%d -> %d) !",
iPad, 0, nPadsMax-1));
continue;
}
gain = gainROC->GetValue(iRow,iPad);
iPad+=3;
while ( input.NextBunch() ){
Int_t startTbin = (Int_t)input.GetStartTimeBin();
Int_t bunchlength = (Int_t)input.GetBunchLength();
const UShort_t *sig = input.GetSignals();
for (Int_t iTime = 0; iTime<bunchlength; iTime++){
Int_t iTimeBin=startTbin-iTime;
if ( iTimeBin < fRecoParam->GetFirstBin() || iTimeBin >= fRecoParam->GetLastBin()){
continue;
AliFatal(Form("Timebin index (%d) outside the range (%d -> %d) !",
iTimeBin, 0, iTimeBin -1));
}
iTimeBin+=3;
Float_t signal=(Float_t)sig[iTime];
if (!calcPedestal && signal <= zeroSup) continue;
if (!calcPedestal) {
Int_t bin = iPad*fMaxTime+iTimeBin;
if (gain>0){
fAllBins[iRow][bin] = signal/gain;
}else{
fAllBins[iRow][bin] =0;
}
fAllSigBins[iRow][fAllNSigBins[iRow]++] = bin;
}else{
fAllBins[iRow][iPad*fMaxTime+iTimeBin] = signal;
}
fAllBins[iRow][iPad*fMaxTime+0]+=1.;
digCounter++;
}
}
}
if (digCounter==0) continue;
}
if ( digCounter>0 ){
ProcessSectorData();
for (Int_t iRow = 0; iRow < fParam->GetNRow(fSector); iRow++) {
Int_t maxPad = fParam->GetNPads(fSector,iRow);
Int_t maxBin = fMaxTime*(maxPad+6);
memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
fAllNSigBins[iRow] = 0;
}
digCounter=0;
}
}
if (rawReader->GetEventId() && fOutput ){
Info("Digits2Clusters", "File %s Event\t%u\tNumber of found clusters : %d\n", fOutput->GetName(),*(rawReader->GetEventId()), fNclusters);
}
if(rawReader->GetEventId()) {
Info("Digits2Clusters", "Event\t%u\tNumber of found clusters : %d\n",*(rawReader->GetEventId()), fNclusters);
}
if(fBClonesArray) {
}
if (fUseHLTClusters == 2 && fNclusters == 0) {
AliInfo("No clusters from TPC Raw data, now trying to read HLT clusters.");
fZWidth = fParam->GetZWidth();
ReadHLTClusters();
}
}
void AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
{
Double_t kMaxDumpSize = 500000;
if (!fOutput) {
fBDumpSignal =kFALSE;
}else{
if (fRecoParam->GetCalcPedestal() && fOutput->GetZipBytes()< kMaxDumpSize) fBDumpSignal =kTRUE;
}
fNcluster=0;
fLoop=1;
Int_t crtime = Int_t((fParam->GetZLength(fSector)-fRecoParam->GetCtgRange()*fRx)/fZWidth-fParam->GetNTBinsL1()-5);
Float_t minMaxCutAbs = fRecoParam->GetMinMaxCutAbs();
Float_t minLeftRightCutAbs = fRecoParam->GetMinLeftRightCutAbs();
Float_t minUpDownCutAbs = fRecoParam->GetMinUpDownCutAbs();
Float_t minMaxCutSigma = fRecoParam->GetMinMaxCutSigma();
Float_t minLeftRightCutSigma = fRecoParam->GetMinLeftRightCutSigma();
Float_t minUpDownCutSigma = fRecoParam->GetMinUpDownCutSigma();
Int_t useOnePadCluster = fRecoParam->GetUseOnePadCluster();
for (Int_t iSig = 0; iSig < fNSigBins; iSig++) {
Int_t i = fSigBins[iSig];
if (i%fMaxTime<=crtime) continue;
Float_t *b = &fBins[i];
if (b[0]<minMaxCutAbs) continue;
if (useOnePadCluster==0){
if (b[-1]+b[1]+b[-fMaxTime]+b[fMaxTime]<=0) continue;
if (b[-1]+b[1]<=0) continue;
if (b[-fMaxTime]+b[fMaxTime]<=0) continue;
}
if ((b[0]+b[-1]+b[1])<minUpDownCutAbs) continue;
if ((b[0]+b[-fMaxTime]+b[fMaxTime])<minLeftRightCutAbs) continue;
if (!IsMaximum(*b,fMaxTime,b)) continue;
Float_t noise = noiseROC->GetValue(fRow, i/fMaxTime);
if (noise>fRecoParam->GetMaxNoise()) continue;
if (b[0]<minMaxCutSigma*noise) continue;
if ((b[0]+b[-1]+b[1])<minUpDownCutSigma*noise) continue;
if ((b[0]+b[-fMaxTime]+b[fMaxTime])<minLeftRightCutSigma*noise) continue;
AliTPCclusterMI c;
Int_t dummy=0;
MakeCluster(i, fMaxTime, fBins, dummy,c);
}
}
Bool_t AliTPCclusterer::AcceptCluster(AliTPCclusterMI *cl){
if (cl->GetMax()<400) return kTRUE;
Double_t ratio = cl->GetQ()/cl->GetMax();
if (cl->GetMax()>700){
if ((ratio - int(ratio)>0.8)) return kFALSE;
}
if ((ratio - int(ratio)<0.95)) return kTRUE;
return kFALSE;
}
Double_t AliTPCclusterer::ProcesSignal(Float_t *signal, Int_t nchannels, Int_t id[3], Double_t &rmsEvent, Double_t &pedestalEvent){
const Int_t kPedMax = 100;
Float_t max = 0;
Float_t maxPos = 0;
Int_t median = -1;
Int_t count0 = 0;
Int_t count1 = 0;
Float_t rmsCalib = rmsEvent;
Float_t pedestalCalib = pedestalEvent;
Int_t firstBin = fRecoParam->GetFirstBin();
UShort_t histo[kPedMax];
for (Int_t i=0; i<kPedMax; i++) histo[i]=0;
for (Int_t i=0; i<fMaxTime; i++){
if (signal[i]<=0) continue;
if (signal[i]>max && i>firstBin) {
max = signal[i];
maxPos = i;
}
if (signal[i]>kPedMax-1) continue;
histo[int(signal[i]+0.5)]++;
count0++;
}
for (Int_t i=1; i<kPedMax; i++){
if (count1<count0*0.5) median=i;
count1+=histo[i];
}
Float_t count10=histo[median] ,mean=histo[median]*median, rms=histo[median]*median*median ;
Float_t count06=histo[median] ,mean06=histo[median]*median, rms06=histo[median]*median*median ;
Float_t count09=histo[median] ,mean09=histo[median]*median, rms09=histo[median]*median*median ;
for (Int_t idelta=1; idelta<10; idelta++){
if (median-idelta<=0) continue;
if (median+idelta>kPedMax) continue;
if (count06<0.6*count1){
count06+=histo[median-idelta];
mean06 +=histo[median-idelta]*(median-idelta);
rms06 +=histo[median-idelta]*(median-idelta)*(median-idelta);
count06+=histo[median+idelta];
mean06 +=histo[median+idelta]*(median+idelta);
rms06 +=histo[median+idelta]*(median+idelta)*(median+idelta);
}
if (count09<0.9*count1){
count09+=histo[median-idelta];
mean09 +=histo[median-idelta]*(median-idelta);
rms09 +=histo[median-idelta]*(median-idelta)*(median-idelta);
count09+=histo[median+idelta];
mean09 +=histo[median+idelta]*(median+idelta);
rms09 +=histo[median+idelta]*(median+idelta)*(median+idelta);
}
if (count10<0.95*count1){
count10+=histo[median-idelta];
mean +=histo[median-idelta]*(median-idelta);
rms +=histo[median-idelta]*(median-idelta)*(median-idelta);
count10+=histo[median+idelta];
mean +=histo[median+idelta]*(median+idelta);
rms +=histo[median+idelta]*(median+idelta)*(median+idelta);
}
}
if (count10) {
mean /=count10;
rms = TMath::Sqrt(TMath::Abs(rms/count10-mean*mean));
}
if (count06) {
mean06/=count06;
rms06 = TMath::Sqrt(TMath::Abs(rms06/count06-mean06*mean06));
}
if (count09) {
mean09/=count09;
rms09 = TMath::Sqrt(TMath::Abs(rms09/count09-mean09*mean09));
}
rmsEvent = rms09;
pedestalEvent = median;
if (AliLog::GetDebugLevel("","AliTPCclusterer")==0) return median;
UInt_t uid[3] = {UInt_t(id[0]),UInt_t(id[1]),UInt_t(id[2])};
if (AliTPCReconstructor::StreamLevel()>0) {
(*fDebugStreamer)<<"Signal"<<
"TimeStamp="<<fTimeStamp<<
"EventType="<<fEventType<<
"Sector="<<uid[0]<<
"Row="<<uid[1]<<
"Pad="<<uid[2]<<
"Max="<<max<<
"MaxPos="<<maxPos<<
"Median="<<median<<
"Mean="<<mean<<
"RMS="<<rms<<
"Mean06="<<mean06<<
"RMS06="<<rms06<<
"Mean09="<<mean09<<
"RMS09="<<rms09<<
"RMSCalib="<<rmsCalib<<
"PedCalib="<<pedestalCalib<<
"\n";
}
Float_t kMin =fRecoParam->GetDumpAmplitudeMin();
Float_t *dsignal = new Float_t[nchannels];
Float_t *dtime = new Float_t[nchannels];
for (Int_t i=0; i<nchannels; i++){
dtime[i] = i;
dsignal[i] = signal[i];
}
if (AliTPCReconstructor::StreamLevel()>0) {
if (max-median>kMin &&maxPos>fRecoParam->GetFirstBin())
(*fDebugStreamer)<<"SignalB"<<
"TimeStamp="<<fTimeStamp<<
"EventType="<<fEventType<<
"Sector="<<uid[0]<<
"Row="<<uid[1]<<
"Pad="<<uid[2]<<
"Max="<<max<<
"MaxPos="<<maxPos<<
"Median="<<median<<
"Mean="<<mean<<
"RMS="<<rms<<
"Mean06="<<mean06<<
"RMS06="<<rms06<<
"Mean09="<<mean09<<
"RMS09="<<rms09<<
"\n";
}
delete [] dsignal;
delete [] dtime;
if (rms06>fRecoParam->GetMaxNoise()) {
pedestalEvent+=1024.;
return 1024+median;
}
return median;
}
Int_t AliTPCclusterer::ReadHLTClusters()
{
if (!fHLTClusterAccess) {
TClass* pCl=NULL;
ROOT::NewFunc_t pNewFunc=NULL;
do {
pCl=TClass::GetClass("AliHLTTPCClusterAccessHLTOUT");
} while (!pCl && gSystem->Load("libAliHLTTPC.so")==0);
if (!pCl || (pNewFunc=pCl->GetNew())==NULL) {
AliError("can not load class description of AliHLTTPCClusterAccessHLTOUT, aborting ...");
return -1;
}
void* p=(*pNewFunc)(NULL);
if (!p) {
AliError("unable to create instance of AliHLTTPCClusterAccessHLTOUT");
return -2;
}
fHLTClusterAccess=reinterpret_cast<TObject*>(p);
}
TObject* pClusterAccess=fHLTClusterAccess;
const Int_t kNIS = fParam->GetNInnerSector();
const Int_t kNOS = fParam->GetNOuterSector();
const Int_t kNS = kNIS + kNOS;
fNclusters = 0;
const AliTPCCalPad * gainTPC = AliTPCcalibDB::Instance() -> GetPadGainFactor();
const AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance() -> GetPadNoise();
const Float_t minMaxCutAbs = fRecoParam -> GetMinMaxCutAbs();
const Float_t minMaxCutSigma = fRecoParam -> GetMinMaxCutSigma();
pClusterAccess->Clear("event");
for(fSector = 0; fSector < kNS; fSector++) {
Int_t iResult = 1;
TString param("sector="); param+=fSector;
pClusterAccess->Clear("sector");
pClusterAccess->Execute("read", param, &iResult);
if (iResult < 0) {
return iResult;
AliError("HLT Clusters can not be found");
}
TObject* pObj=pClusterAccess->FindObject("clusterarray");
if (pObj==NULL) {
AliError("HLT clusters requested, but not cluster array not present");
return -4;
}
TObjArray* clusterArray=dynamic_cast<TClonesArray*>(pObj);
if (!clusterArray) {
AliError("HLT cluster array is not of class type TClonesArray");
return -5;
}
AliDebug(4,Form("Reading %d clusters from HLT for sector %d", clusterArray->GetEntriesFast(), fSector));
Int_t nClusterSector=0;
Int_t nClusterSectorGood=0;
Int_t nRows=fParam->GetNRow(fSector);
const AliTPCCalROC * gainROC = gainTPC -> GetCalROC(fSector);
const AliTPCCalROC * noiseROC = noiseTPC -> GetCalROC(fSector);
for (fRow = 0; fRow < nRows; fRow++) {
fRowCl->SetID(fParam->GetIndex(fSector, fRow));
if (fOutput) fOutput->GetBranch("Segment")->SetAddress(&fRowCl);
fNcluster=0;
fRx = fParam->GetPadRowRadii(fSector, fRow);
fPadLength = fParam->GetPadPitchLength(fSector, fRow);
fPadWidth = fParam->GetPadPitchWidth();
fMaxPad = fParam->GetNPads(fSector,fRow);
fMaxBin = fMaxTime*(fMaxPad+6);
fBins = fAllBins[fRow];
fSigBins = fAllSigBins[fRow];
fNSigBins = fAllNSigBins[fRow];
for (Int_t i=0; i<clusterArray->GetEntriesFast(); i++) {
if (!clusterArray->At(i))
continue;
AliTPCclusterMI* cluster=dynamic_cast<AliTPCclusterMI*>(clusterArray->At(i));
if (!cluster) continue;
if (cluster->GetRow()!=fRow) continue;
nClusterSector++;
const Int_t currentPad = TMath::Nint(cluster->GetPad());
const Float_t maxCharge = cluster->GetMax();
const Float_t gain = gainROC -> GetValue(fRow, currentPad);
const Float_t noise = noiseROC -> GetValue(fRow, currentPad);
if (!(gain>0)) continue;
if (noise>fRecoParam->GetMaxNoise()) continue;
if (maxCharge<minMaxCutAbs) continue;
if (maxCharge<minMaxCutSigma*noise) continue;
nClusterSectorGood++;
AddCluster(*cluster, NULL, 0);
}
FillRow();
fRowCl->GetArray()->Clear("c");
}
if (nClusterSector!=clusterArray->GetEntriesFast()) {
AliError(Form("Failed to read %d out of %d HLT clusters",
clusterArray->GetEntriesFast()-nClusterSector,
clusterArray->GetEntriesFast()));
}
fNclusters+=nClusterSectorGood;
}
pClusterAccess->Clear("event");
Info("Digits2Clusters", "Number of converted HLT clusters : %d", fNclusters);
return 0;
}