-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
+//**************************************************************************
+// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+// * *
+// * Author: The ALICE Off-line Project. *
+// * Contributors are mentioned in the code where appropriate. *
+// * *
+// * Permission to use, copy, modify and distribute this software and its *
+// * documentation strictly for non-commercial purposes is hereby granted *
+// * without fee, provided that the above copyright notice appears in all *
+// * copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************/
/* $Id$ */
#include "AliTRDCalibraVdriftLinearFit.h"
#include "AliTRDcalibDB.h"
#include "AliTRDCommonParam.h"
-#include "AliTRDmcmTracklet.h"
-#include "AliTRDmcm.h"
-#include "AliTRDtrigParam.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcluster.h"
+#include "AliTRDtrack.h"
#include "AliTRDtrackV1.h"
#include "AliTRDrawStreamBase.h"
#include "AliRawReader.h"
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
:TObject()
,fGeo(0)
+ ,fIsHLT(kFALSE)
,fMcmCorrectAngle(kFALSE)
,fCH2dOn(kFALSE)
,fPH2dOn(kFALSE)
,fRelativeScale(0)
,fThresholdClusterPRF2(15.0)
,fLimitChargeIntegration(kFALSE)
+ ,fFillWithZero(kFALSE)
+ ,fNormalizeNbOfCluster(kFALSE)
+ ,fMaxCluster(0)
+ ,fNbMaxCluster(0)
,fCalibraMode(new AliTRDCalibraMode())
,fDebugStreamer(0)
,fDebugLevel(0)
,fDetectorPreviousTrack(-1)
,fMCMPrevious(-1)
,fROBPrevious(-1)
- ,fNumberClusters(18)
+ ,fNumberClusters(1)
,fNumberClustersf(30)
,fProcent(6.0)
,fDifference(17)
,fPHPlace(0x0)
,fPHValue(0x0)
,fGoodTracklet(kTRUE)
+ ,fLinearFitterTracklet(0x0)
,fEntriesCH(0x0)
,fEntriesLinearFitter(0x0)
,fCalibraVector(0x0)
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
:TObject(c)
,fGeo(0)
+ ,fIsHLT(c.fIsHLT)
,fMcmCorrectAngle(c.fMcmCorrectAngle)
,fCH2dOn(c.fCH2dOn)
,fPH2dOn(c.fPH2dOn)
,fRelativeScale(c.fRelativeScale)
,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
,fLimitChargeIntegration(c.fLimitChargeIntegration)
+ ,fFillWithZero(c.fFillWithZero)
+ ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
+ ,fMaxCluster(c.fMaxCluster)
+ ,fNbMaxCluster(c.fNbMaxCluster)
,fCalibraMode(0x0)
,fDebugStreamer(0)
,fDebugLevel(c.fDebugLevel)
,fPHPlace(0x0)
,fPHValue(0x0)
,fGoodTracklet(c.fGoodTracklet)
+ ,fLinearFitterTracklet(0x0)
,fEntriesCH(0x0)
,fEntriesLinearFitter(0x0)
,fCalibraVector(0x0)
if ( fCalDetGain ) delete fCalDetGain;
if ( fCalROCGain ) delete fCalROCGain;
+ if( fLinearFitterTracklet ) { delete fLinearFitterTracklet; }
+
+ delete [] fPHPlace;
+ delete [] fPHValue;
+ delete [] fEntriesCH;
+ delete [] fEntriesLinearFitter;
+ delete [] fAmpTotal;
+
+ for(Int_t idet=0; idet<AliTRDgeometry::kNdet; idet++){
+ TLinearFitter *f = (TLinearFitter*)fLinearFitterArray.At(idet);
+ if(f) { delete f;}
+ }
if (fGeo) {
delete fGeo;
}
//
if ( fDebugStreamer ) delete fDebugStreamer;
+ fDebugStreamer = 0x0;
}
//_____________________________________________________________________________
// Some parameters
fTimeMax = cal->GetNumberOfTimeBins();
fSf = parCom->GetSamplingFrequency();
- fRelativeScale = 20;
+ if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
+ else fRelativeScale = 1.18;
fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
+ fNumberClusters = (Int_t)(0.5*fTimeMax);
- //calib object from database used for reconstruction
- if(fCalDetGain) delete fCalDetGain;
- fCalDetGain = new AliTRDCalDet(*(cal->GetGainFactorDet()));
+ // Init linear fitter
+ if(!fLinearFitterTracklet) {
+ fLinearFitterTracklet = new TLinearFitter(2,"pol1");
+ fLinearFitterTracklet->StoreData(kTRUE);
+ }
+ //calib object from database used for reconstruction
+ if( fCalDetGain ){
+ fCalDetGain->~AliTRDCalDet();
+ new(fCalDetGain) AliTRDCalDet(*(cal->GetGainFactorDet()));
+ }else fCalDetGain = new AliTRDCalDet(*(cal->GetGainFactorDet()));
+
// Calcul Xbins Chambd0, Chamb2
Int_t ntotal0 = CalculateTotalNumberOfBins(0);
Int_t ntotal1 = CalculateTotalNumberOfBins(1);
//If the same track, then look if the previous detector is in
//the same plane, if yes: not a good track
- if ((GetPlane(detector) == GetPlane(fDetectorPreviousTrack))) {
+ if ((GetLayer(detector) == GetLayer(fDetectorPreviousTrack))) {
return kFALSE;
}
}
// Get calib objects
- if( fCalROCGain ) delete fCalROCGain;
- fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
-
+ if( fCalROCGain ){
+ if(!fIsHLT){
+ fCalROCGain->~AliTRDCalROC();
+ new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ }
+ }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+
}
// Reset the detectbjobsor
const AliTRDseedV1 *tracklet = 0x0; // tracklet per plane
- AliTRDcluster *cl = 0x0; // cluster attached now to the tracklet
+ AliTRDcluster *cl = 0x0; // cluster attached now to the tracklet
+ Bool_t newtr = kTRUE; // new track
+ // Get cal
+ AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ if (!cal) {
+ AliInfo("Could not get calibDB");
+ return kFALSE;
+ }
///////////////////////////
// loop over the tracklet
//////////////////////////////////////////
// localisation of the tracklet and dqdl
//////////////////////////////////////////
- Int_t plane = tracklet->GetPlane();
+ Int_t layer = tracklet->GetPlane();
Int_t ic = 0;
while(!(cl = tracklet->GetClusters(ic++))) continue;
Int_t detector = cl->GetDetector();
if (detector != fDetectorPreviousTrack) {
- // don't use the rest of this track if in the same plane
- if ((plane == GetPlane(fDetectorPreviousTrack))) {
- break;
+ // if not a new track
+ if(!newtr){
+ // don't use the rest of this track if in the same plane
+ if (layer == GetLayer(fDetectorPreviousTrack)) {
+ //printf("bad tracklet, same layer for detector %d\n",detector);
+ break;
+ }
}
//Localise the detector bin
LocalisationDetectorXbins(detector);
- // Get cal
- AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
- if (!cal) {
- AliInfo("Could not get calibDB");
- return kFALSE;
- }
// Get calib objects
- if( fCalROCGain ) delete fCalROCGain;
- fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ if( fCalROCGain ){
+ if(!fIsHLT){
+ fCalROCGain->~AliTRDCalROC();
+ new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ }
+ }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+
// reset
fDetectorPreviousTrack = detector;
}
-
+ newtr = kFALSE;
////////////////////////////
// loop over the clusters
if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
} // if a good tracklet
-
}
-
-
+
return kTRUE;
}
////////////////
Int_t detector = ((AliTRDcluster *) t->GetCluster(index0))->GetDetector(); //detector
// parameters of the track
- Double_t snp = t->GetSnpPlane(GetPlane(detector)); // sin angle in the plan yx track
- Double_t tgl = t->GetTglPlane(GetPlane(detector)); // dz/dl and not dz/dx!
+ Double_t snp = t->GetSnpPlane(GetLayer(detector)); // sin angle in the plan yx track
+ Double_t tgl = t->GetTglPlane(GetLayer(detector)); // dz/dl and not dz/dx!
Double_t tnp = 0.0; // tan angle in the plan xy track
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Float_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx now from dz/dl
// tilting pad and cross row
Int_t crossrow = 0; // if it crosses a pad row
Int_t rowp = -1; // if it crosses a pad row
- AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetPlane(detector),GetChamber(detector));
+ AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(detector),GetStack(detector));
Double_t tiltingangle = padplane->GetTiltingAngle(); // tiltingangle of the pad
Float_t tnt = TMath::Tan(tiltingangle/180.*TMath::Pi()); // tan tiltingangle
// linear fit
- TLinearFitter linearFitterTracklet = TLinearFitter(2,"pol1"); // TLinearFitter per tracklet
+ fLinearFitterTracklet->ClearPoints();
Double_t dydt = 0.0; // dydt tracklet after straight line fit
Double_t errorpar = 0.0; // error after straight line fit on dy/dt
Double_t pointError = 0.0; // error after straight line fit
Int_t nbli = 0; // number linear fitter points
- linearFitterTracklet.StoreData(kFALSE);
- linearFitterTracklet.ClearPoints();
//////////////////////////////
// loop over clusters
if(k==0) rowp = row;
if(row != rowp) crossrow = 1;
- linearFitterTracklet.AddPoint(&timeis,ycluster,1);
+ fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
nbli++;
}
//////////////////////////////
// linear fit
//////////////////////////////
- if(nbli <= 2) return kFALSE;
+ if(nbli <= 2){
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
+ }
TVectorD pars;
- linearFitterTracklet.Eval();
- linearFitterTracklet.GetParameters(pars);
- pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/nbli);
- errorpar = linearFitterTracklet.GetParError(1)*pointError;
+ fLinearFitterTracklet->Eval();
+ fLinearFitterTracklet->GetParameters(pars);
+ pointError = TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
+ errorpar = fLinearFitterTracklet->GetParError(1)*pointError;
dydt = pars[1];
-
+ fLinearFitterTracklet->ClearPoints();
+
/////////////////////////////
// debug
////////////////////////////
Int_t nbclusters = index1-index0;
- Int_t plane = GetPlane(fDetectorPreviousTrack);
+ Int_t layer = GetLayer(fDetectorPreviousTrack);
(* fDebugStreamer) << "FindP1TrackPHtracklet1"<<
//"snpright="<<snpright<<
"nbclusters="<<nbclusters<<
"detector="<<fDetectorPreviousTrack<<
- "plane="<<plane<<
+ "layer="<<layer<<
"\n";
}
////////////
//Variables
////////////
- TLinearFitter linearFitterTracklet = TLinearFitter(2,"pol1"); // TLinearFitter per tracklet
// results of the linear fit
Double_t dydt = 0.0; // dydt tracklet after straight line fit
Double_t errorpar = 0.0; // error after straight line fit on dy/dt
Int_t crossrow = 0; // if it crosses a pad row
Int_t rowp = -1; // if it crosses a pad row
Float_t tnt = tracklet->GetTilt(); // tan tiltingangle
-
- linearFitterTracklet.StoreData(kFALSE);
- linearFitterTracklet.ClearPoints();
+ fLinearFitterTracklet->ClearPoints();
+
///////////////////////////////////////////
// Take the parameters of the track
Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
Double_t tnp = 0.0; // dy/dx at the end of the chamber
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Double_t tgl = tracklet->GetTgl(); // dz/dl
Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
if(rowp==-1) rowp = row;
if(row != rowp) crossrow = 1;
- linearFitterTracklet.AddPoint(&timeis,ycluster,1);
+ fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
nbli++;
}
////////////////////////////////////
// Do the straight line fit now
///////////////////////////////////
+ if(nbli <= 2){
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
+ }
TVectorD pars;
- linearFitterTracklet.Eval();
- linearFitterTracklet.GetParameters(pars);
- pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/nbli);
- errorpar = linearFitterTracklet.GetParError(1)*pointError;
+ fLinearFitterTracklet->Eval();
+ fLinearFitterTracklet->GetParameters(pars);
+ pointError = TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
+ errorpar = fLinearFitterTracklet->GetParError(1)*pointError;
dydt = pars[1];
+ //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
+ fLinearFitterTracklet->ClearPoints();
////////////////////////////////
// Debug stuff
}
- Int_t plane = GetPlane(fDetectorPreviousTrack);
-
+ Int_t layer = GetLayer(fDetectorPreviousTrack);
+
(* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
//"snpright="<<snpright<<
+ "nbli="<<nbli<<
"nbclusters="<<nbclusters<<
"detector="<<fDetectorPreviousTrack<<
- "plane="<<plane<<
+ "layer="<<layer<<
"snp="<<snp<<
"tnp="<<tnp<<
"tgl="<<tgl<<
if(nbclusters < fNumberClusters) return kFALSE;
if(nbclusters > fNumberClustersf) return kFALSE;
- if(pointError >= 0.1) return kFALSE;
+ if(pointError >= 0.3) return kFALSE;
if(crossrow == 1) return kFALSE;
///////////////////////
padPositions[k] = 0.0;
}
// Take the tgl and snp with the track t now
- Double_t tgl = t->GetTglPlane(GetPlane(detector)); //dz/dl and not dz/dx
- Double_t snp = t->GetSnpPlane(GetPlane(detector)); // sin angle in xy plan
+ Double_t tgl = t->GetTglPlane(GetLayer(detector)); //dz/dl and not dz/dx
+ Double_t snp = t->GetSnpPlane(GetLayer(detector)); // sin angle in xy plan
Float_t dzdx = 0.0; // dzdx
Float_t tnp = 0.0;
if(TMath::Abs(snp) < 1.0){
- tnp = snp / (TMath::Sqrt(1-snp*snp));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
}
// linear fitter
- TLinearFitter fitter(2,"pol1");
- fitter.StoreData(kFALSE);
- fitter.ClearPoints();
-
+ fLinearFitterTracklet->ClearPoints();
///////////////////////////
// calcul the tnp group
}
}
}
- if(echec) return kFALSE;
-
+ if(echec) {
+ delete [] padPositions;
+ return kFALSE;
+ }
//////////////////////
// loop clusters
//Take the cluster
AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
Short_t *signals = cl->GetSignals();
- Double_t time = cl->GetPadTime();
+ Double_t time = cl->GetLocalTimeBin();
//Calculate x if possible
Float_t xcenter = 0.0;
Bool_t echec1 = kTRUE;
Double_t padPosition = xcenter + cl->GetPadCol();
padPositions[k] = padPosition;
nb3pc++;
- fitter.AddPoint(&time, padPosition,1);
+ fLinearFitterTracklet->AddPoint(&time, padPosition,1);
}//clusters loop
/////////////////////////////
// fit
////////////////////////////
- if(nb3pc < 3) return kFALSE;
- fitter.Eval();
+ if(nb3pc < 3) {
+ delete [] padPositions;
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
+ }
+ fLinearFitterTracklet->Eval();
TVectorD line(2);
- fitter.GetParameters(line);
+ fLinearFitterTracklet->GetParameters(line);
Float_t pointError = -1.0;
- pointError = TMath::Sqrt(fitter.GetChisquare()/nb3pc);
+ if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+ pointError = TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+ }
+ fLinearFitterTracklet->ClearPoints();
/////////////////////////////////////////////////////
// Now fill the PRF: second loop over clusters
//Take the cluster
AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
Short_t *signals = cl->GetSignals(); // signal
- Double_t time = cl->GetPadTime(); // time bin
+ Double_t time = cl->GetLocalTimeBin(); // time bin
Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
Float_t padPos = cl->GetPadCol(); // middle pad
Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
Int_t caligroup = fCalibraMode->GetXbins(2)+ grouplocal; // calcul the corresponding group
Float_t xcl = cl->GetY(); // y cluster
Float_t qcl = cl->GetQ(); // charge cluster
- Int_t plane = GetPlane(detector); // plane
- Int_t chamber = GetChamber(detector); // chamber
+ Int_t layer = GetLayer(detector); // layer
+ Int_t stack = GetStack(detector); // stack
Double_t xdiff = dpad; // reconstructed position constant
Double_t x = dpad; // reconstructed position moved
Float_t ep = pointError; // error of fit
(* fDebugStreamer) << "HandlePRFtracklet"<<
"caligroup="<<caligroup<<
"detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<< stack <<
"npoints="<<npoints<<
"Np="<<nb3pc<<
"ep="<<ep<<
(* fDebugStreamer) << "HandlePRFtracklet"<<
"caligroup="<<caligroup<<
"detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<<stack<<
"npoints="<<npoints<<
"Np="<<nb3pc<<
"ep="<<ep<<
(* fDebugStreamer) << "HandlePRFtracklet"<<
"caligroup="<<caligroup<<
"detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<<stack<<
"npoints="<<npoints<<
"Np="<<nb3pc<<
"ep="<<ep<<
}
}
}
+ delete [] padPositions;
return kTRUE;
}
//
//
+ //printf("begin\n");
///////////////////////////////////////////
// Take the parameters of the track
//////////////////////////////////////////
Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
Double_t tnp = 0.0; // dy/dx at the end of the chamber
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Double_t tgl = tracklet->GetTgl(); // dz/dl
Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
}
}
// do nothing if out of tnp range
+ //printf("echec %d\n",(Int_t)echec);
if(echec) return kFALSE;
///////////////////////
for(Int_t k = 0; k < AliTRDseed::knTimebins; k++){
padPositions[k] = 0.0;
}
- TLinearFitter fitter(2,"pol1"); // TLinearFitter for the linear fit in the drift region
- fitter.StoreData(kFALSE);
- fitter.ClearPoints();
-
+ fLinearFitterTracklet->ClearPoints();
+
+ //printf("loop clusters \n");
////////////////////////////
// loop over the clusters
////////////////////////////
for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
if(!(cl = tracklet->GetClusters(ic))) continue;
- Double_t time = cl->GetPadTime();
+ Double_t time = cl->GetLocalTimeBin();
if((time<=7) || (time>=21)) continue;
Short_t *signals = cl->GetSignals();
Float_t xcenter = 0.0;
Double_t padPosition = xcenter + cl->GetPadCol();
padPositions[ic] = padPosition;
nb3pc++;
- fitter.AddPoint(&time, padPosition,1);
+ fLinearFitterTracklet->AddPoint(&time, padPosition,1);
}//clusters loop
-
+ //printf("Fin loop clusters \n");
//////////////////////////////
// fit with a straight line
/////////////////////////////
- if(nb3pc < 3) return kFALSE;
- fitter.Eval();
+ if(nb3pc < 3){
+ delete [] padPositions;
+ fLinearFitterTracklet->ClearPoints();
+ delete [] padPositions;
+ return kFALSE;
+ }
+ fLinearFitterTracklet->Eval();
TVectorD line(2);
- fitter.GetParameters(line);
+ fLinearFitterTracklet->GetParameters(line);
Float_t pointError = -1.0;
- pointError = TMath::Sqrt(fitter.GetChisquare()/nb3pc);
-
+ if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+ pointError = TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+ }
+ fLinearFitterTracklet->ClearPoints();
+
+ //printf("PRF second loop \n");
////////////////////////////////////////////////
// Fill the PRF: Second loop over clusters
//////////////////////////////////////////////
if(!(cl = tracklet->GetClusters(ic))) continue;
Short_t *signals = cl->GetSignals(); // signal
- Double_t time = cl->GetPadTime(); // time bin
+ Double_t time = cl->GetLocalTimeBin(); // time bin
Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
Float_t padPos = cl->GetPadCol(); // middle pad
Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
Int_t caligroup = fCalibraMode->GetXbins(2)+ grouplocal; // calcul the corresponding group
Float_t xcl = cl->GetY(); // y cluster
Float_t qcl = cl->GetQ(); // charge cluster
- Int_t plane = GetPlane(fDetectorPreviousTrack); // plane
- Int_t chamber = GetChamber(fDetectorPreviousTrack); // chamber
+ Int_t layer = GetLayer(fDetectorPreviousTrack); // layer
+ Int_t stack = GetStack(fDetectorPreviousTrack); // stack
Double_t xdiff = dpad; // reconstructed position constant
Double_t x = dpad; // reconstructed position moved
Float_t ep = pointError; // error of fit
Float_t signal4 = (Float_t)signals[4]; // signal
Float_t signal5 = (Float_t)signals[5]; // signal at the border
+
+
/////////////////////
// Debug stuff
////////////////////
(* fDebugStreamer) << "HandlePRFtrackletV1"<<
"caligroup="<<caligroup<<
"detector="<<fDetectorPreviousTrack<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<<stack<<
"npoints="<<nbclusters<<
"Np="<<nb3pc<<
"ep="<<ep<<
(* fDebugStreamer) << "HandlePRFtrackletV1"<<
"caligroup="<<caligroup<<
"detector="<<fDetectorPreviousTrack<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<<stack<<
"npoints="<<nbclusters<<
"Np="<<nb3pc<<
"ep="<<ep<<
(* fDebugStreamer) << "HandlePRFtrackletV1"<<
"caligroup="<<caligroup<<
"detector="<<fDetectorPreviousTrack<<
- "plane="<<plane<<
- "chamber="<<chamber<<
+ "layer="<<layer<<
+ "stack="<<stack<<
"npoints="<<nbclusters<<
"Np="<<nb3pc<<
"ep="<<ep<<
} // second loop over clusters
+ delete [] padPositions;
return kTRUE;
}
//
Int_t ntotal = 0;
+
+ // All together
+ if((fCalibraMode->GetNz(i)==100) && (fCalibraMode->GetNrphi(i)==100)){
+ ntotal = 1;
+ AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+ return ntotal;
+ }
+
+ // Per Supermodule
+ if((fCalibraMode->GetNz(i)==10) && (fCalibraMode->GetNrphi(i)==10)){
+ ntotal = 18;
+ AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+ return ntotal;
+ }
+
+ // More
fCalibraMode->ModePadCalibration(2,i);
fCalibraMode->ModePadFragmentation(0,2,0,i);
fCalibraMode->SetDetChamb2(i);
}
}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
+{
+ //
+ // Set the mode of calibration group all together
+ //
+ if(fVector2d == kTRUE) {
+ AliInfo("Can not work with the vector method");
+ return;
+ }
+ fCalibraMode->SetAllTogether(i);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetPerSuperModule(Int_t i)
+{
+ //
+ // Set the mode of calibration group per supermodule
+ //
+ if(fVector2d == kTRUE) {
+ AliInfo("Can not work with the vector method");
+ return;
+ }
+ fCalibraMode->SetPerSuperModule(i);
+
+}
+
//____________Set the pad calibration variables for the detector_______________
Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
{
// fragmentation of idect
for (Int_t i = 0; i < 3; i++) {
- fCalibraMode->ModePadCalibration((Int_t) GetChamber(detector),i);
- fCalibraMode->ModePadFragmentation((Int_t) GetPlane(detector)
- , (Int_t) GetChamber(detector)
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(detector),i);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(detector)
+ , (Int_t) GetStack(detector)
, (Int_t) GetSector(detector),i);
}
Int_t time = cl->GetPadTime();
//Correct for the gain coefficient used in the database for reconstruction
- Float_t correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
+ Float_t correctthegain = 1.0;
+ if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
+ else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
Float_t correction = 1.0;
Float_t normalisation = 6.67;
// we divide with gain in AliTRDclusterizer::Transform...
if(nbclusters < fNumberClusters) return;
if(nbclusters > fNumberClustersf) return;
-
+
+
+ // Normalize with the number of clusters
+ Double_t normalizeCst = fRelativeScale;
+ if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;
// See if the track goes through different zones
for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
fNumberUsedCh[0]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
break;
case 2:
// One of the two very big
if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
}
if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd+1]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+1.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd+1]/normalizeCst,fCalibraMode->GetXbins(0)+fd+1.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
// One of the two very big
if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
}
if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
}
}
}
}
}
+ // See if noise before and after
+ if(fMaxCluster > 0) {
+ if(fPHValue[0] > fMaxCluster) return;
+ if(fTimeMax > fNbMaxCluster) {
+ for(Int_t k = (fTimeMax-fNbMaxCluster); k < fTimeMax; k++){
+ if(fPHValue[k] > fMaxCluster) return;
+ }
+ }
+ }
+
+ //printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);
+
if(nbclusters < fNumberClusters) return;
if(nbclusters > fNumberClustersf) return;
fNumberUsedPh[0]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ }
//printf("Fill the time bin %d with %f\n",i,fPHValue[i]);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ }
}
}
break;
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ }
}
}
}
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ }
}
}
}
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ }
}
}
}
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ }
}
}
}
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd1)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd1,i,fPHValue[i]);
+ }
}
}
}
fNumberUsedPh[1]++;
for (Int_t i = 0; i < fTimeMax; i++) {
if (fHisto2d) {
- fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ if(fFillWithZero) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fPH2d->Fill((Float_t) i/fSf,(fCalibraMode->GetXbins(1)+fd2)+0.5,(Float_t) fPHValue[i]);
+ }
}
if (fVector2d) {
- fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ if(fFillWithZero) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ else {
+ if(((Float_t) fPHValue[i] > 0.0)) fCalibraVector->UpdateVectorPH(fDetectorPreviousTrack,fd2,i,fPHValue[i]);
+ }
}
}
}
return withInput;
-}
-//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
-{
- //
- // Event Processing loop - AliTRDrawStreamBase
- // Use old AliTRDmcmtracklet code
- // 0 timebin problem
- // 1 no input
- // 2 input
- //
- // Algorithm with mcm tracklet
- //
-
- Int_t withInput = 1;
-
- AliTRDmcm mcm = AliTRDmcm(0);
- AliTRDtrigParam *param = AliTRDtrigParam::Instance();
- rawStream->SetSharedPadReadout(kTRUE);
-
- fDetectorPreviousTrack = -1;
- fMCMPrevious = -1;
- fROBPrevious = -1;
- Int_t row = -1;
- Int_t nbtimebin = 0;
- Int_t baseline = 10;
-
-
- if(!nocheck){
-
- fTimeMax = 0;
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
- row = rawStream->GetRow();
-
-
- if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
- if(fDetectorPreviousTrack == -1){
-
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- if(nbtimebin == 0) return 0;
- if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
- fTimeMax = nbtimebin;
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
- param->SetTimeRange(0,fTimeMax);
-
- //baseline = rawStream->GetCommonAdditive(); // common additive baseline
-
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t adc = rawStream->GetADC();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
- for(Int_t itime = 0; itime < nbtimebin; itime++){
- mcm.SetADC(adc,itime,(signal[itime]-baseline));
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(fROBPrevious);
- mcm.SetChaId(fDetectorPreviousTrack);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- }
- else{
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
- row = rawStream->GetRow();
-
- if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- //baseline = rawStream->GetCommonAdditive(); // common baseline
-
- fTimeMax = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
- param->SetTimeRange(0,fTimeMax);
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t adc = rawStream->GetADC();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
- for(Int_t itime = 0; itime < fTimeMax; itime++){
- mcm.SetADC(adc,itime,(signal[itime]-baseline));
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
- // reset
- mcm.Reset();
- mcm.SetRobId(fROBPrevious);
- mcm.SetChaId(fDetectorPreviousTrack);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
- }
-
- return withInput;
-
}
//_____________________________________________________________________
Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck)
return 0;
#endif
-}
-//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliRawReader *rawReader, Bool_t nocheck)
-{
- //
- // Event processing loop - AliRawReader
- // use the old mcm traklet code
- //
-
- AliTRDrawStreamBase rawStream(rawReader);
-
- rawReader->Select("TRD");
-
- return ProcessEventDAQV1(&rawStream, nocheck);
-}
-//_________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(
-#ifdef ALI_DATE
- eventHeaderStruct *event,
- Bool_t nocheck
-#else
- eventHeaderStruct* /*event*/,
- Bool_t /*nocheck*/
-
-#endif
- )
-{
- //
- // process date event
- // use the old mcm tracklet code
- //
-#ifdef ALI_DATE
- AliRawReader *rawReader = new AliRawReaderDate((void*)event);
- Int_t result=ProcessEventDAQV1(rawReader, nocheck);
- delete rawReader;
- return result;
-#else
- Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
- return 0;
-#endif
-
}
//////////////////////////////////////////////////////////////////////////////
// Routine inside the DAQ process
/////////////////////////////////////////////////////////////////////////////
//_______________________________________________________________________
-Int_t AliTRDCalibraFillHisto::FillDAQ(AliTRDmcm *mcm){
-
- //
- // Return 2 if some tracklets are found and used, 1 if nothing
- //
-
- Int_t nbev = 0;
-
- if(mcm->Run()){
-
- for (Int_t iSeed = 0; iSeed < 4; iSeed++) {
-
- if (mcm->GetSeedCol()[iSeed] < 0) {
- continue;
- }
-
- nbev += TestTracklet(mcm->GetChaId(),mcm->GetRow(),iSeed,mcm);
- }
-
- }
-
- if(nbev > 0) nbev = 2;
- else nbev = 1;
-
- return nbev;
-
-}
-//__________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::TestTracklet( Int_t idet, Int_t row, Int_t iSeed, AliTRDmcm *mcm){
-
- //
- // Build the tracklet and return if the tracklet if finally used or not (1/0)
- //
-
- Int_t nbev = 0;
-
- AliTRDmcmTracklet mcmtracklet = AliTRDmcmTracklet();
- //mcmtracklet.Reset();
- mcmtracklet.SetDetector(idet);
- mcmtracklet.SetRow(row);
- mcmtracklet.SetN(0);
-
- Int_t iCol, iCol1, iCol2, track[3];
- iCol = mcm->GetSeedCol()[iSeed]; // 0....20 (MCM)
- mcm->GetColRange(iCol1,iCol2); // range in the pad plane
-
- Float_t amp[3];
- for (Int_t iTime = 0; iTime < fTimeMax; iTime++) {
-
- amp[0] = mcm->GetADC(iCol-1,iTime);
- amp[1] = mcm->GetADC(iCol ,iTime);
- amp[2] = mcm->GetADC(iCol+1,iTime);
-
- if(mcm->IsCluster(iCol,iTime)) {
-
- mcmtracklet.AddCluster(iCol+iCol1,iTime,amp,track);
-
- }
- else if ((iCol+1+1) < 21) {
-
- amp[0] = mcm->GetADC(iCol-1+1,iTime);
- amp[1] = mcm->GetADC(iCol +1,iTime);
- amp[2] = mcm->GetADC(iCol+1+1,iTime);
-
- if(mcm->IsCluster(iCol+1,iTime)) {
-
- mcmtracklet.AddCluster(iCol+1+iCol1,iTime,amp,track);
-
- }
-
- }
-
- }
-
-
- nbev = UpdateHistogramcm(&mcmtracklet);
-
- return nbev;
-
-}
-//____________Online trackling in AliTRDtrigger________________________________
-Int_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
-{
- //
- // Return if the tracklet is finally used or not (1/0) for calibration
- //
-
- Int_t used = 1;
-
- //fGoodTracklet = kTRUE;
-
- // Localisation of the Xbins involved
- Int_t idect = trk->GetDetector();
- Int_t idectrue = trk->GetDetector();
- //idect = 0;
-
- Int_t nbclusters = trk->GetNclusters();
-
- // Eventuelle correction due to track angle in z direction
- Float_t correction = 1.0;
- if (fMcmCorrectAngle) {
- Float_t z = trk->GetRowz();
- Float_t r = trk->GetTime0();
- correction = r / TMath::Sqrt((r*r+z*z));
- }
-
- //row
- Int_t row = trk->GetRow();
-
-
- // Boucle sur les clusters
- // Condition on number of cluster: don't come from the middle of the detector
-
- Double_t amph[36];
- for(Int_t k =0; k < 36; k++) amph[k]=0.0;
- Double_t ampTotal = 0.0;
-
- for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
-
- Float_t amp[3] = { 0.0, 0.0, 0.0 };
- Int_t time = trk->GetClusterTime(icl);
- Int_t col = trk->GetClusterCol(icl);
-
- //CheckGoodTrackletV0(idect,row,col);
-
- amp[0] = trk->GetClusterADC(icl)[0] * correction;
- amp[1] = trk->GetClusterADC(icl)[1] * correction;
- amp[2] = trk->GetClusterADC(icl)[2] * correction;
-
- ampTotal += (Float_t) (amp[0]+amp[1]+amp[2]);
- amph[time]=amp[0]+amp[1]+amp[2];
-
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
- TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
- if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- Double_t amp0 = amp[0];
- Double_t amp1 = amp[1];
- Double_t amp2 = amp[2];
-
- (* fDebugStreamer) << "UpdateHistogramcm0"<<
- "nbclusters="<<nbclusters<<
- "amp0="<<amp0<<
- "amp1="<<amp1<<
- "amp2="<<amp2<<
- "time="<<time<<
- "col="<<col<<
- "row="<<row<<
- "detector="<<idectrue<<
- "\n";
- }
-
- } // Boucle clusters
-
- if((amph[0] > 100.0) || (!fGoodTracklet) || (trk->GetNclusters() < fNumberClusters) || (trk->GetNclusters() > fNumberClustersf)) used = 0;
-
- if (used == 1) {
- for(Int_t k = 0; k < fTimeMax; k++) UpdateDAQ(idect,0,0,k,amph[k],fTimeMax);
- //((TH2I *)GetCH2d()->Fill(ampTotal/30.0,idect));
- } // Condition cut
-
-
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
- TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
- if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- Double_t amph0 = amph[0];
- Double_t amphlast = amph[fTimeMax-1];
- Double_t rms = TMath::RMS(fTimeMax,amph);
- Int_t goodtracklet = (Int_t) fGoodTracklet;
-
- (* fDebugStreamer) << "UpdateHistogramcm1"<<
- "nbclusters="<<nbclusters<<
- "ampTotal="<<ampTotal<<
- "row="<<row<<
- "detector="<<idectrue<<
- "amph0="<<amph0<<
- "amphlast="<<amphlast<<
- "goodtracklet="<<goodtracklet<<
- "rms="<<rms<<
- "\n";
- }
-
- return used;
-
-}
-//_______________________________________________________________________
Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){
//
//if((TMath::RMS(fTimeMax,sum) <= 10.0) && (sum[0] > 200.0)) return 1;
if(used == 0){
for(Int_t it = 0; it < fTimeMax; it++){
- UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
+ if(fFillWithZero) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
+ else{
+ if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
+ }
}
// Geometrical functions
///////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::GetPlane(Int_t d) const
+Int_t AliTRDCalibraFillHisto::GetLayer(Int_t d) const
{
//
- // Reconstruct the plane number from the detector number
+ // Reconstruct the layer number from the detector number
//
return ((Int_t) (d % 6));
}
//_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::GetChamber(Int_t d) const
+Int_t AliTRDCalibraFillHisto::GetStack(Int_t d) const
{
//
- // Reconstruct the chamber number from the detector number
+ // Reconstruct the stack number from the detector number
//
- Int_t fgkNplan = 6;
+ const Int_t kNlayer = 6;
- return ((Int_t) (d % 30) / fgkNplan);
+ return ((Int_t) (d % 30) / kNlayer);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff