-/**************************************************************************
- * 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 <TTree.h>
#include <TProfile2D.h>
#include <TProfile.h>
#include <TFile.h>
-#include <TChain.h>
#include <TStyle.h>
#include <TCanvas.h>
-#include <TGraphErrors.h>
#include <TObjArray.h>
+#include <TObject.h>
#include <TH1F.h>
#include <TH2I.h>
#include <TH2.h>
#include <TStopwatch.h>
#include <TMath.h>
#include <TDirectory.h>
-#include <TROOT.h>
#include <TTreeStream.h>
#include <TVectorD.h>
+#include <TLinearFitter.h>
#include "AliLog.h"
-#include "AliCDBManager.h"
-#include "AliRawReader.h"
-#include "AliRawReaderDate.h"
#include "AliTRDCalibraFillHisto.h"
#include "AliTRDCalibraMode.h"
#include "AliTRDCalibraVector.h"
+#include "AliTRDCalibraVdriftLinearFit.h"
#include "AliTRDcalibDB.h"
#include "AliTRDCommonParam.h"
-#include "AliTRDmcmTracklet.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcluster.h"
#include "AliTRDtrack.h"
-#include "AliTRDRawStream.h"
+#include "AliTRDtrackV1.h"
+#include "AliTRDrawStreamBase.h"
+#include "AliRawReader.h"
+#include "AliRawReaderDate.h"
#include "AliTRDgeometry.h"
+#include "./Cal/AliTRDCalROC.h"
+#include "./Cal/AliTRDCalDet.h"
#ifdef ALI_DATE
#include "event.h"
#endif
+
ClassImp(AliTRDCalibraFillHisto)
AliTRDCalibraFillHisto* AliTRDCalibraFillHisto::fgInstance = 0;
}
}
+
//______________________________________________________________________________________
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
:TObject()
,fGeo(0)
- ,fMITracking(kFALSE)
- ,fMcmTracking(kFALSE)
- ,fMcmCorrectAngle(kFALSE)
+ ,fIsHLT(kFALSE)
,fCH2dOn(kFALSE)
,fPH2dOn(kFALSE)
,fPRF2dOn(kFALSE)
,fLinearFitterDebugOn(kFALSE)
,fRelativeScale(0)
,fThresholdClusterPRF2(15.0)
+ ,fLimitChargeIntegration(kFALSE)
+ ,fFillWithZero(kFALSE)
+ ,fNormalizeNbOfCluster(kFALSE)
+ ,fMaxCluster(0)
+ ,fNbMaxCluster(0)
,fCalibraMode(new AliTRDCalibraMode())
,fDebugStreamer(0)
,fDebugLevel(0)
- ,fDetectorAliTRDtrack(kFALSE)
,fDetectorPreviousTrack(-1)
- ,fNumberClusters(18)
+ ,fMCMPrevious(-1)
+ ,fROBPrevious(-1)
+ ,fNumberClusters(1)
+ ,fNumberClustersf(30)
,fProcent(6.0)
,fDifference(17)
,fNumberTrack(0)
,fTimeMax(0)
,fSf(10.0)
- ,fNumberBinCharge(100)
- ,fNumberBinPRF(40)
- ,fNgroupprf(0)
- ,fListClusters(new TObjArray())
- ,fPar0(0x0)
- ,fPar1(0x0)
- ,fPar2(0x0)
- ,fPar3(0x0)
- ,fPar4(0x0)
+ ,fNumberBinCharge(50)
+ ,fNumberBinPRF(10)
+ ,fNgroupprf(3)
,fAmpTotal(0x0)
,fPHPlace(0x0)
,fPHValue(0x0)
,fGoodTracklet(kTRUE)
- ,fGoodTrack(kTRUE)
+ ,fLinearFitterTracklet(0x0)
,fEntriesCH(0x0)
,fEntriesLinearFitter(0x0)
,fCalibraVector(0x0)
,fPH2d(0x0)
,fPRF2d(0x0)
,fCH2d(0x0)
- ,fLinearFitterArray(0)
- ,fLinearFitterHistoArray(0)
+ ,fLinearFitterArray(540)
+ ,fLinearVdriftFit(0x0)
+ ,fCalDetGain(0x0)
+ ,fCalROCGain(0x0)
{
//
// Default constructor
fNumberUsedCh[1] = 0;
fNumberUsedPh[0] = 0;
fNumberUsedPh[1] = 0;
-
+
fGeo = new AliTRDgeometry();
-
+
}
//______________________________________________________________________________________
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
:TObject(c)
,fGeo(0)
- ,fMITracking(c.fMITracking)
- ,fMcmTracking(c.fMcmTracking)
- ,fMcmCorrectAngle(c.fMcmCorrectAngle)
+ ,fIsHLT(c.fIsHLT)
,fCH2dOn(c.fCH2dOn)
,fPH2dOn(c.fPH2dOn)
,fPRF2dOn(c.fPRF2dOn)
,fLinearFitterDebugOn(c.fLinearFitterDebugOn)
,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)
- ,fDetectorAliTRDtrack(c.fDetectorAliTRDtrack)
,fDetectorPreviousTrack(c.fDetectorPreviousTrack)
+ ,fMCMPrevious(c.fMCMPrevious)
+ ,fROBPrevious(c.fROBPrevious)
,fNumberClusters(c.fNumberClusters)
+ ,fNumberClustersf(c.fNumberClustersf)
,fProcent(c.fProcent)
,fDifference(c.fDifference)
,fNumberTrack(c.fNumberTrack)
,fNumberBinCharge(c.fNumberBinCharge)
,fNumberBinPRF(c.fNumberBinPRF)
,fNgroupprf(c.fNgroupprf)
- ,fListClusters(new TObjArray())
- ,fPar0(c.fPar0)
- ,fPar1(c.fPar1)
- ,fPar2(c.fPar2)
- ,fPar3(c.fPar3)
- ,fPar4(c.fPar4)
- ,fAmpTotal(c.fAmpTotal)
- ,fPHPlace(c.fPHPlace)
- ,fPHValue(c.fPHValue)
+ ,fAmpTotal(0x0)
+ ,fPHPlace(0x0)
+ ,fPHValue(0x0)
,fGoodTracklet(c.fGoodTracklet)
- ,fGoodTrack(c.fGoodTrack)
- ,fEntriesCH(c.fEntriesCH)
- ,fEntriesLinearFitter(fEntriesLinearFitter)
+ ,fLinearFitterTracklet(0x0)
+ ,fEntriesCH(0x0)
+ ,fEntriesLinearFitter(0x0)
,fCalibraVector(0x0)
,fPH2d(0x0)
,fPRF2d(0x0)
,fCH2d(0x0)
- ,fLinearFitterArray(0)
- ,fLinearFitterHistoArray(0)
+ ,fLinearFitterArray(540)
+ ,fLinearVdriftFit(0x0)
+ ,fCalDetGain(0x0)
+ ,fCalROCGain(0x0)
{
//
// Copy constructor
fCH2d = new TH2I(*c.fCH2d);
fCH2d->SetDirectory(0);
}
- if(c.fLinearFitterOn){
- fLinearFitterArray.Expand(540);
- for (Int_t cb = 0; cb < 540; cb++){
- const TLinearFitter *linearFitter = (TLinearFitter*)c.fLinearFitterArray.UncheckedAt(cb);
- if ( linearFitter != 0x0 ) fLinearFitterArray.AddAt(new TLinearFitter(*linearFitter), cb);
- }
- }
- if(c.fLinearFitterDebugOn){
- fLinearFitterHistoArray.Expand(540);
- for (Int_t cb = 0; cb < 540; cb++){
- const TH2F *linearfitterhisto = (TH2F*)c.fLinearFitterHistoArray.UncheckedAt(cb);
- if ( linearfitterhisto != 0x0 ){
- TH2F *hNew = new TH2F(*linearfitterhisto);
- hNew->SetDirectory(0);
- fLinearFitterHistoArray.AddAt(hNew,cb);
- }
- }
+ if(c.fLinearVdriftFit){
+ fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit(*c.fLinearVdriftFit);
}
+
+ if(c.fCalDetGain) fCalDetGain = new AliTRDCalDet(*c.fCalDetGain);
+ if(c.fCalROCGain) fCalROCGain = new AliTRDCalROC(*c.fCalROCGain);
+
if (fGeo) {
delete fGeo;
}
fGeo = new AliTRDgeometry();
-
}
//____________________________________________________________________________________
ClearHistos();
if ( fDebugStreamer ) delete fDebugStreamer;
+ 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(fLinearVdriftFit) delete fLinearVdriftFit;
if (fGeo) {
delete fGeo;
}
}
-
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::Destroy()
{
delete fgInstance;
fgInstance = 0x0;
}
-
}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::DestroyDebugStreamer()
+{
+ //
+ // Delete DebugStreamer
+ //
+ if ( fDebugStreamer ) delete fDebugStreamer;
+ fDebugStreamer = 0x0;
+
+}
//_____________________________________________________________________________
void AliTRDCalibraFillHisto::ClearHistos()
{
delete fPRF2d;
fPRF2d = 0x0;
}
-
+
}
+//////////////////////////////////////////////////////////////////////////////////
+// calibration with AliTRDtrackV1: Init, Update
+//////////////////////////////////////////////////////////////////////////////////
//____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
-Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
+Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
{
//
- // For the offline tracking
- // This function will be called in the function AliReconstruction::Run()
- // Init the calibration mode (Nz, Nrphi), the 2D histograms if fHisto2d = kTRUE,
+ // Init the histograms and stuff to be filled
//
// DB Setting
}
// Some parameters
- fTimeMax = cal->GetNumberOfTimeBins();
- fSf = parCom->GetSamplingFrequency();
- fRelativeScale = 20;
-
- //Init the tracklet parameters
- fPar0 = new Double_t[fTimeMax];
- fPar1 = new Double_t[fTimeMax];
- fPar2 = new Double_t[fTimeMax];
- fPar3 = new Double_t[fTimeMax];
- fPar4 = new Double_t[fTimeMax];
-
- for(Int_t k = 0; k < fTimeMax; k++){
- fPar0[k] = 0.0;
- fPar1[k] = 0.0;
- fPar2[k] = 0.0;
- fPar3[k] = 0.0;
- fPar4[k] = 0.0;
- }
-
- //If vector method On initialised all the stuff
- if(fVector2d){
+ if(nboftimebin > 0) fTimeMax = nboftimebin;
+ else fTimeMax = cal->GetNumberOfTimeBinsDCS();
+ if(fTimeMax <= 0) fTimeMax = 30;
+ fSf = parCom->GetSamplingFrequency();
+ if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
+ else fRelativeScale = 1.18;
+ fNumberClustersf = fTimeMax;
+ fNumberClusters = (Int_t)(0.5*fTimeMax);
+
+ // 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);
+ Int_t ntotal2 = CalculateTotalNumberOfBins(2);
+
+ // If vector method On initialised all the stuff
+ if(fVector2d){
fCalibraVector = new AliTRDCalibraVector();
fCalibraVector->SetNumberBinCharge(fNumberBinCharge);
fCalibraVector->SetTimeMax(fTimeMax);
fCalibraVector->SetNumberBinPRF(fNumberBinPRF);
fCalibraVector->SetPRFRange(1.5);
}
+ for(Int_t k = 0; k < 3; k++){
+ fCalibraVector->SetDetCha0(k,fCalibraMode->GetDetChamb0(k));
+ fCalibraVector->SetDetCha2(k,fCalibraMode->GetDetChamb2(k));
+ }
+ fCalibraVector->SetNzNrphi(0,fCalibraMode->GetNz(0),fCalibraMode->GetNrphi(0));
+ fCalibraVector->SetNzNrphi(1,fCalibraMode->GetNz(1),fCalibraMode->GetNrphi(1));
+ fCalibraVector->SetNzNrphi(2,fCalibraMode->GetNz(2),fCalibraMode->GetNrphi(2));
+ fCalibraVector->SetNbGroupPRF(fNgroupprf);
}
// Create the 2D histos corresponding to the pad groupCalibration mode
,fCalibraMode->GetNz(0)
,fCalibraMode->GetNrphi(0)));
- // Calcul the number of Xbins
- Int_t Ntotal0 = CalculateTotalNumberOfBins(0);
// Create the 2D histo
if (fHisto2d) {
- CreateCH2d(Ntotal0);
+ CreateCH2d(ntotal0);
}
// Variable
fAmpTotal = new Float_t[TMath::Max(fCalibraMode->GetDetChamb2(0),fCalibraMode->GetDetChamb0(0))];
fAmpTotal[k] = 0.0;
}
//Statistics
- fEntriesCH = new Int_t[Ntotal0];
- for(Int_t k = 0; k < Ntotal0; k++){
+ fEntriesCH = new Int_t[ntotal0];
+ for(Int_t k = 0; k < ntotal0; k++){
fEntriesCH[k] = 0;
}
+
}
if (fPH2dOn) {
,fCalibraMode->GetNz(1)
,fCalibraMode->GetNrphi(1)));
- // Calcul the number of Xbins
- Int_t Ntotal1 = CalculateTotalNumberOfBins(1);
// Create the 2D histo
if (fHisto2d) {
- CreatePH2d(Ntotal1);
+ CreatePH2d(ntotal1);
}
// Variable
fPHPlace = new Short_t[fTimeMax];
}
}
if (fLinearFitterOn) {
- fLinearFitterArray.Expand(540);
- fLinearFitterArray.SetName("ArrayLinearFitters");
- fEntriesLinearFitter = new Int_t[540];
- for(Int_t k = 0; k < 540; k++){
- fEntriesLinearFitter[k] = 0;
- }
if(fLinearFitterDebugOn) {
- fLinearFitterHistoArray.Expand(540);
- fLinearFitterHistoArray.SetName("ArrayHistos");
+ fLinearFitterArray.SetName("ArrayLinearFitters");
+ fEntriesLinearFitter = new Int_t[540];
+ for(Int_t k = 0; k < 540; k++){
+ fEntriesLinearFitter[k] = 0;
+ }
}
+ fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
}
if (fPRF2dOn) {
AliInfo(Form("The pad calibration mode for the PRF calibration: Nz %d, and Nrphi %d"
,fCalibraMode->GetNz(2)
,fCalibraMode->GetNrphi(2)));
-
- // Calcul the number of Xbins
- Int_t Ntotal2 = CalculateTotalNumberOfBins(2);
// Create the 2D histo
if (fHisto2d) {
- CreatePRF2d(Ntotal2);
+ CreatePRF2d(ntotal2);
}
}
return kTRUE;
}
-
-//____________Functions for filling the histos in the code_____________________
-
-//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::ResetTrack()
-{
- //
- // For the offline tracking
- // This function will be called in the function
- // AliTRDtracker::FollowBackPropagation() at the beginning
- // Reset the parameter to know we have a new TRD track
- //
-
- fDetectorAliTRDtrack = kFALSE;
- fGoodTrack = kTRUE;
- return kTRUE;
-
-}
-//____________Offine tracking in the AliTRDtracker_____________________________
-void AliTRDCalibraFillHisto::ResetfVariables()
+//____________Offline tracking in the AliTRDtracker____________________________
+Bool_t AliTRDCalibraFillHisto::UpdateHistograms(const AliTRDtrack *t)
{
//
- // Reset values per tracklet
+ // Use AliTRDtrack for the calibration
//
- // Reset the list of clusters
- fListClusters->Clear();
-
- //Reset the tracklet parameters
- for(Int_t k = 0; k < fTimeMax; k++){
- fPar0[k] = 0.0;
- fPar1[k] = 0.0;
- fPar2[k] = 0.0;
- fPar3[k] = 0.0;
- fPar4[k] = 0.0;
- }
-
-
- //Reset good tracklet
- fGoodTracklet = kTRUE;
+
+ AliTRDcluster *cl = 0x0; // pointeur to cluster
+ Int_t index0 = 0; // index of the first cluster in the current chamber
+ Int_t index1 = 0; // index of the current cluster in the current chamber
+
+ //////////////////////////////
+ // loop over the clusters
+ ///////////////////////////////
+ while((cl = t->GetCluster(index1))){
+
+ /////////////////////////////////////////////////////////////////////////
+ // Fill the infos for the previous clusters if not the same detector
+ ////////////////////////////////////////////////////////////////////////
+ Int_t detector = cl->GetDetector();
+ if ((detector != fDetectorPreviousTrack) &&
+ (index0 != index1)) {
+
+ fNumberTrack++;
+
+ //If the same track, then look if the previous detector is in
+ //the same plane, if yes: not a good track
+ if ((GetLayer(detector) == GetLayer(fDetectorPreviousTrack))) {
+ return kFALSE;
+ }
+
+ // Fill only if the track doesn't touch a masked pad or doesn't
+ if (fGoodTracklet) {
+
+ // drift velocity unables to cut bad tracklets
+ Bool_t pass = FindP1TrackPHtracklet(t,index0,index1);
+
+ // Gain calibration
+ if (fCH2dOn) {
+ FillTheInfoOfTheTrackCH(index1-index0);
+ }
+
+ // PH calibration
+ if (fPH2dOn) {
+ FillTheInfoOfTheTrackPH();
+ }
+
+ if(pass && fPRF2dOn) HandlePRFtracklet(t,index0,index1);
+
+
+ } // if a good tracklet
+
+ // reset stuff
+ ResetfVariablestracklet();
+ index0 = index1;
+
+ } // Fill at the end the charge
- // Reset the fPHValue
- if (fPH2dOn) {
- //Reset the fPHValue and fPHPlace
- for (Int_t k = 0; k < fTimeMax; k++) {
- fPHValue[k] = 0.0;
- fPHPlace[k] = -1;
- }
- }
- // Reset the fAmpTotal where we put value
- if (fCH2dOn) {
- for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
- fAmpTotal[k] = 0.0;
+ /////////////////////////////////////////////////////////////
+ // Localise and take the calib gain object for the detector
+ ////////////////////////////////////////////////////////////
+ if (detector != fDetectorPreviousTrack) {
+
+ //Localise the detector
+ LocalisationDetectorXbins(detector);
+
+ // Get cal
+ AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ if (!cal) {
+ AliInfo("Could not get calibDB");
+ return kFALSE;
+ }
+
+ // Get calib objects
+ if( fCalROCGain ){
+ if(!fIsHLT){
+ fCalROCGain->~AliTRDCalROC();
+ new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ }
+ }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+
}
- }
-
-}
-//____________Offline tracking in the AliTRDtracker____________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDcluster *cl, AliTRDtrack *t)
-{
- //
- // For the offline tracking
- // This function will be called in the function
- // AliTRDtracker::FollowBackPropagation() in the loop over the clusters
- // of TRD tracks
- // Fill the 2D histos or the vectors with the info of the clusters at
- // the end of a detectors if the track is "good"
- //
-
- // Localisation of the detector
- Int_t detector = cl->GetDetector();
-
- // Fill the infos for the previous clusters if not the same
- // detector anymore or if not the same track
- if (((detector != fDetectorPreviousTrack) || (!fDetectorAliTRDtrack)) &&
- (fDetectorPreviousTrack != -1)) {
- fNumberTrack++;
+ // Reset the detectbjobsor
+ fDetectorPreviousTrack = detector;
+
+ ///////////////////////////////////////
+ // Store the info of the cluster
+ ///////////////////////////////////////
+ Int_t row = cl->GetPadRow();
+ Int_t col = cl->GetPadCol();
+ CheckGoodTrackletV1(cl);
+ Int_t group[2] = {0,0};
+ if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,row,col);
+ if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,row,col);
+ StoreInfoCHPHtrack(cl,t->GetClusterdQdl(index1),group,row,col);
+
+ index1++;
+
+ } // while on clusters
+
+ ///////////////////////////
+ // Fill the last plane
+ //////////////////////////
+ if( index0 != index1 ){
- // If the same track, then look if the previous detector is in
- // the same plane, if yes: not a good track
- if (fDetectorAliTRDtrack &&
- (GetPlane(detector) <= GetPlane(fDetectorPreviousTrack))) {
- fGoodTrack = kFALSE;
- }
-
- // Fill only if the track doesn't touch a masked pad or doesn't
- // appear in the middle (fGoodTrack)
- if (fGoodTrack && fGoodTracklet) {
-
+ fNumberTrack++;
+
+ if (fGoodTracklet) {
+
// drift velocity unables to cut bad tracklets
- Bool_t pass = FindP1TrackPH();
+ Bool_t pass = FindP1TrackPHtracklet(t,index0,index1);
// Gain calibration
if (fCH2dOn) {
- FillTheInfoOfTheTrackCH();
+ FillTheInfoOfTheTrackCH(index1-index0);
}
// PH calibration
if (fPH2dOn) {
FillTheInfoOfTheTrackPH();
}
-
- if(pass && fPRF2dOn) HandlePRF();
-
- } // if a good track
+ if(pass && fPRF2dOn) HandlePRFtracklet(t,index0,index1);
+
+ } // if a good tracklet
- ResetfVariables();
-
- } // Fill at the end the charge
-
- // Calcul the position of the detector
- if (detector != fDetectorPreviousTrack) {
- LocalisationDetectorXbins(detector);
}
-
- // Reset the detector
- fDetectorPreviousTrack = detector;
- fDetectorAliTRDtrack = kTRUE;
-
- // Store the infos of the tracklets
- AliTRDcluster *kcl = new AliTRDcluster(*cl);
- fListClusters->Add((TObject *)kcl);
- Int_t time = cl->GetLocalTimeBin();
- fPar0[time] = t->GetY();
- fPar1[time] = t->GetZ();
- fPar2[time] = t->GetSnp();
- fPar3[time] = t->GetTgl();
- fPar4[time] = t->Get1Pt();
-
- // Store the info bis of the tracklet
- Int_t *rowcol = CalculateRowCol(cl);
- CheckGoodTracklet(detector,rowcol);
- Int_t group[2] = {0,0};
- if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,rowcol);
- if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,rowcol);
- StoreInfoCHPH(cl,t,group);
+
+ // reset stuff
+ ResetfVariablestracklet();
return kTRUE;
}
-//____________Online trackling in AliTRDtrigger________________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
+//____________Offline tracking in the AliTRDtracker____________________________
+Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
{
//
- // For the tracking
- // This function will be called in the function AliTRDtrigger::TestTracklet
- // before applying the pt cut on the tracklets
- // Fill the infos for the tracklets fTrkTest if the tracklets is "good"
+ // Use AliTRDtrackV1 for the calibration
//
-
- // Localisation of the Xbins involved
- Int_t idect = trk->GetDetector();
- LocalisationDetectorXbins(idect);
- // Get the parameter object
+
+ const AliTRDseedV1 *tracklet = 0x0; // tracklet per plane
+ 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;
}
-
- // Reset
- ResetfVariables();
-
- // Row of the tracklet and position in the pad groups
- Int_t *rowcol = new Int_t[2];
- rowcol[0] = trk->GetRow();
- Int_t group[3] = {-1,-1,-1};
- // 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));
- }
-
- // Boucle sur les clusters
- // Condition on number of cluster: don't come from the middle of the detector
- if (trk->GetNclusters() >= fNumberClusters) {
-
- 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);
- rowcol[1] = trk->GetClusterCol(icl);
-
- amp[0] = trk->GetClusterADC(icl)[0] * correction;
- amp[1] = trk->GetClusterADC(icl)[1] * correction;
- amp[2] = trk->GetClusterADC(icl)[2] * correction;
-
-
- if ((amp[0] < 0.0) ||
- (amp[1] < 0.0) ||
- (amp[2] < 0.0)) {
- continue;
- }
-
- // Col of cluster and position in the pad groups
- if(fCH2dOn) {
- group[0] = CalculateCalibrationGroup(0,rowcol);
- fAmpTotal[(Int_t) group[0]] += (Float_t) (amp[0]+amp[1]+amp[2]);
- }
- if(fPH2dOn) {
- group[1] = CalculateCalibrationGroup(1,rowcol);
- fPHPlace[time] = group[1];
- fPHValue[time] = (Float_t) (amp[0]+amp[1]+amp[2]);
+ ///////////////////////////
+ // loop over the tracklet
+ ///////////////////////////
+ for(Int_t itr = 0; itr < 6; itr++){
+
+ if(!(tracklet = t->GetTracklet(itr))) continue;
+ if(!tracklet->IsOK()) continue;
+ fNumberTrack++;
+ ResetfVariablestracklet();
+
+ //////////////////////////////////////////
+ // localisation of the tracklet and dqdl
+ //////////////////////////////////////////
+ Int_t layer = tracklet->GetPlane();
+ Int_t ic = 0;
+ while(!(cl = tracklet->GetClusters(ic++))) continue;
+ Int_t detector = cl->GetDetector();
+ if (detector != fDetectorPreviousTrack) {
+ // 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;
+ }
}
- if(fPRF2dOn) group[2] = CalculateCalibrationGroup(2,rowcol);
-
- // See if we are not near a masked pad fGoodTracklet
- CheckGoodTracklet(idect,rowcol);
-
- // Fill PRF direct without tnp bins...only for monitoring...
- if (fPRF2dOn && fGoodTracklet) {
-
- if ((amp[0] > fThresholdClusterPRF2) &&
- (amp[1] > fThresholdClusterPRF2) &&
- (amp[2] > fThresholdClusterPRF2) &&
- ((amp[0]*amp[2]/(amp[1]*amp[1])) < 0.06)) {
-
- // Security of the denomiateur is 0
- if ((((Float_t) (((Float_t) amp[1]) * ((Float_t) amp[1])))
- / ((Float_t) (((Float_t) amp[0]) * ((Float_t) amp[2])))) != 1.0) {
- Float_t xcenter = 0.5 * (TMath::Log(amp[2] / amp[0]))
- / (TMath::Log((amp[1]*amp[1]) / (amp[0]*amp[2])));
- Float_t ycenter = amp[1] / (amp[0] + amp[1] + amp[2]);
-
- if (TMath::Abs(xcenter) < 0.5) {
- Float_t yminus = amp[0] / (amp[0]+amp[1]+amp[2]);
- Float_t ymax = amp[2] / (amp[0]+amp[1]+amp[2]);
- // Fill only if it is in the drift region!
- if (((Float_t) time / fSf) > 0.3) {
- if (fHisto2d) {
- fPRF2d->Fill(xcenter,(fCalibraMode->GetXbins(2)+group[2]+0.5),ycenter);
- fPRF2d->Fill(-(xcenter+1.0),(fCalibraMode->GetXbins(2)+group[2]+0.5),yminus);
- fPRF2d->Fill((1.0-xcenter),(fCalibraMode->GetXbins(2)+group[2]+0.5),ymax);
- }
- if (fVector2d) {
- fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+group[2],xcenter,ycenter);
- fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+group[2],-(xcenter+1.0),yminus);
- fCalibraVector->UpdateVectorPRF(fCalibraMode->GetXbins(2)+group[2],(1.0-xcenter),ymax);
- }
- }//in the drift region
- }//in the middle
- }//denominateur security
- }//cluster shape and thresholds
- }//good and PRF On
+ //Localise the detector bin
+ LocalisationDetectorXbins(detector);
+ // Get calib objects
+ if( fCalROCGain ){
+ if(!fIsHLT){
+ fCalROCGain->~AliTRDCalROC();
+ new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ }
+ }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
- } // Boucle clusters
-
- // Fill the charge
- if(fGoodTracklet){
- if (fCH2dOn) FillTheInfoOfTheTrackCH();
- if (fPH2dOn) FillTheInfoOfTheTrackPH();
+ // reset
+ fDetectorPreviousTrack = detector;
+ }
+ newtr = kFALSE;
+
+ ////////////////////////////
+ // loop over the clusters
+ ////////////////////////////
+ Int_t nbclusters = 0;
+ for(int jc=0; jc<AliTRDseedV1::kNtb; jc++){
+ if(!(cl = tracklet->GetClusters(jc))) continue;
+ nbclusters++;
+
+ // Store the info bis of the tracklet
+ Int_t row = cl->GetPadRow();
+ Int_t col = cl->GetPadCol();
+ CheckGoodTrackletV1(cl);
+ Int_t group[2] = {0,0};
+ if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,row,col);
+ if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,row,col);
+ StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col);
}
+
+ ////////////////////////////////////////
+ // Fill the stuffs if a good tracklet
+ ////////////////////////////////////////
+ if (fGoodTracklet) {
- fNumberTrack++;
-
- } // Condition on number of clusters
+ // drift velocity unables to cut bad tracklets
+ Bool_t pass = FindP1TrackPHtrackletV1(tracklet, nbclusters);
+
+ //printf("pass %d and nbclusters %d\n",pass,nbclusters);
+ // Gain calibration
+ if (fCH2dOn) {
+ FillTheInfoOfTheTrackCH(nbclusters);
+ }
+
+ // PH calibration
+ if (fPH2dOn) {
+ FillTheInfoOfTheTrackPH();
+ }
+
+ if(pass && fPRF2dOn) HandlePRFtrackletV1(tracklet,nbclusters);
+
+ } // if a good tracklet
+ }
+
return kTRUE;
}
-//_____________________________________________________________________________
-Int_t *AliTRDCalibraFillHisto::CalculateRowCol(AliTRDcluster *cl) const
+///////////////////////////////////////////////////////////////////////////////////
+// Routine inside the update with AliTRDtrack
+///////////////////////////////////////////////////////////////////////////////////
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtracklet(const AliTRDtrack *t, Int_t index0, Int_t index1)
{
//
- // Calculate the row and col number of the cluster
+ // Drift velocity calibration:
+ // Fit the clusters with a straight line
+ // From the slope find the drift velocity
//
+ //Number of points: if less than 3 return kFALSE
+ Int_t npoints = index1-index0;
+ if(npoints <= 2) return kFALSE;
- Int_t *rowcol = new Int_t[2];
- rowcol[0] = 0;
- rowcol[1] = 0;
+ /////////////////
+ //Variables
+ ////////////////
+ Int_t detector = ((AliTRDcluster *) t->GetCluster(index0))->GetDetector(); //detector
+ // parameters of the track
+ 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)*(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(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
+ 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
+
+ //////////////////////////////
+ // loop over clusters
+ ////////////////////////////
+ for(Int_t k = 0; k < npoints; k++){
+
+ AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
+ if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
+ Double_t ycluster = cl->GetY();
+ Int_t time = cl->GetPadTime();
+ Double_t timeis = time/fSf;
+ //Double_t q = cl->GetQ();
+ //See if cross two pad rows
+ Int_t row = cl->GetPadRow();
+ if(k==0) rowp = row;
+ if(row != rowp) crossrow = 1;
- // Localisation of the detector
- Int_t detector = cl->GetDetector();
- Int_t chamber = GetChamber(detector);
- Int_t plane = GetPlane(detector);
+ fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
+ nbli++;
- // Localisation of the cluster
- Double_t pos[3] = { 0.0, 0.0, 0.0 };
- pos[0] = ((AliCluster *)cl)->GetX();
- pos[1] = cl->GetY();
- pos[2] = cl->GetZ();
+ }
- // Position of the cluster
- AliTRDpadPlane *padplane = fGeo->GetPadPlane(plane,chamber);
- Int_t row = padplane->GetPadRowNumber(pos[2]);
- //Do not take from here because it was corrected from ExB already....
- //Double_t offsetz = padplane->GetPadRowOffset(row,pos[2]);
- //Double_t offsettilt = padplane->GetTiltOffset(offsetz);
- //Int_t col = padplane->GetPadColNumber(pos[1] + offsettilt,offsetz);
- //Int_t col = padplane->GetPadColNumber(pos[1]+offsettilt);
- Int_t col = cl->GetPad();
+ //////////////////////////////
+ // linear fit
+ //////////////////////////////
+ if(nbli <= 2){
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
+ }
+ TVectorD pars;
+ fLinearFitterTracklet->Eval();
+ fLinearFitterTracklet->GetParameters(pars);
+ pointError = TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
+ errorpar = fLinearFitterTracklet->GetParError(1)*pointError;
+ dydt = pars[1];
+ fLinearFitterTracklet->ClearPoints();
+
+ /////////////////////////////
+ // debug
+ ////////////////////////////
+ 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
+ }
+
+
+ (* fDebugStreamer) << "FindP1TrackPHtracklet0"<<
+ //"snpright="<<snpright<<
+ "npoints="<<npoints<<
+ "nbli="<<nbli<<
+ "detector="<<detector<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "tnt="<<tnt<<
+ "dydt="<<dydt<<
+ "dzdx="<<dzdx<<
+ "crossrow="<<crossrow<<
+ "errorpar="<<errorpar<<
+ "pointError="<<pointError<<
+ "\n";
- //return
- rowcol[0] = row;
- rowcol[1] = col;
- return rowcol;
-
-}
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CheckGoodTracklet(Int_t detector, Int_t *rowcol)
-{
- //
- // See if we are not near a masked pad
- //
- Int_t row = rowcol[0];
- Int_t col = rowcol[1];
+ Int_t nbclusters = index1-index0;
+ Int_t layer = GetLayer(fDetectorPreviousTrack);
- if (!IsPadOn(detector, col, row)) {
- fGoodTracklet = kFALSE;
- }
+ (* fDebugStreamer) << "FindP1TrackPHtracklet1"<<
+ //"snpright="<<snpright<<
+ "nbclusters="<<nbclusters<<
+ "detector="<<fDetectorPreviousTrack<<
+ "layer="<<layer<<
+ "\n";
- if (col > 0) {
- if (!IsPadOn(detector, col-1, row)) {
- fGoodTracklet = kFALSE;
- }
}
+
+ ///////////////////////////
+ // quality cuts
+ ///////////////////////////
+ if(npoints < fNumberClusters) return kFALSE;
+ if(npoints > fNumberClustersf) return kFALSE;
+ if(pointError >= 0.1) return kFALSE;
+ if(crossrow == 1) return kFALSE;
- if (col < 143) {
- if (!IsPadOn(detector, col+1, row)) {
- fGoodTracklet = kFALSE;
+ ////////////////////////////
+ // fill
+ ////////////////////////////
+ if(fLinearFitterOn){
+ //Add to the linear fitter of the detector
+ if( TMath::Abs(snp) < 1.){
+ Double_t x = tnp-dzdx*tnt;
+ if(fLinearFitterDebugOn) {
+ (GetLinearFitter(detector,kTRUE))->AddPoint(&x,dydt);
+ fEntriesLinearFitter[detector]++;
+ }
+ fLinearVdriftFit->Update(detector,x,pars[1]);
}
}
+ return kTRUE;
}
-//_____________________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t col, Int_t row) const
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
{
//
- // Look in the choosen database if the pad is On.
- // If no the track will be "not good"
+ // Drift velocity calibration:
+ // Fit the clusters with a straight line
+ // From the slope find the drift velocity
//
- // Get the parameter object
- AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
- if (!cal) {
- AliInfo("Could not get calibDB");
- return kFALSE;
- }
+ ////////////////////////////////////////////////
+ //Number of points: if less than 3 return kFALSE
+ /////////////////////////////////////////////////
+ if(nbclusters <= 2) return kFALSE;
+
+ ////////////
+ //Variables
+ ////////////
+ // 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
+ Double_t pointError = 0.0; // error after straight line fit
+ // pad row problemes: avoid tracklet that cross pad rows, tilting angle in the constant
+ 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
+ fLinearFitterTracklet->ClearPoints();
+
- if (!cal->IsChamberInstalled(detector) ||
- cal->IsChamberMasked(detector) ||
- cal->IsPadMasked(detector,col,row)) {
- return kFALSE;
- }
- else {
- return kTRUE;
+ ///////////////////////////////////////////
+ // Take the parameters of the track
+ //////////////////////////////////////////
+ // take now the snp, tnp and tgl from 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)*(1.+snp));
+ }
+ Double_t tgl = tracklet->GetTgl(); // dz/dl
+ Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
+ // at the entrance
+ //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
+ //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
+ //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
+ // at the end with correction due to linear fit
+ //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
+ //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
+
+
+ ////////////////////////////
+ // loop over the clusters
+ ////////////////////////////
+ Int_t nbli = 0;
+ AliTRDcluster *cl = 0x0;
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
+ if(!(cl = tracklet->GetClusters(ic))) continue;
+ if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
+
+ Double_t ycluster = cl->GetY();
+ Int_t time = cl->GetPadTime();
+ Double_t timeis = time/fSf;
+ //See if cross two pad rows
+ Int_t row = cl->GetPadRow();
+ if(rowp==-1) rowp = row;
+ if(row != rowp) crossrow = 1;
+
+ fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
+ nbli++;
+
+ //////////////////////////////
+ // Check no shared clusters
+ //////////////////////////////
+ for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
+ if((cl = tracklet->GetClusters(icc))) crossrow = 1;
+ }
}
-}
-//_____________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::CalculateCalibrationGroup(Int_t i, Int_t *rowcol) const
-{
- //
- // Calculate the calibration group number for i
- //
-
- // Row of the cluster and position in the pad groups
- Int_t posr = 0;
- if (fCalibraMode->GetNnZ(i) != 0) {
- posr = (Int_t) rowcol[0] / fCalibraMode->GetNnZ(i);
+ ////////////////////////////////////
+ // Do the straight line fit now
+ ///////////////////////////////////
+ if(nbli <= 2){
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
}
+ TVectorD pars;
+ 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();
-
- // Col of the cluster and position in the pad groups
- Int_t posc = 0;
- if (fCalibraMode->GetNnRphi(i) != 0) {
- posc = (Int_t) rowcol[1] / fCalibraMode->GetNnRphi(i);
- }
-
- return posc*fCalibraMode->GetNfragZ(i)+posr;
-
-}
-//____________________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
-{
- //
- // Calculate the total number of calibration groups
- //
-
- Int_t Ntotal = 0;
- fCalibraMode->ModePadCalibration(2,i);
- fCalibraMode->ModePadFragmentation(0,2,0,i);
- fCalibraMode->SetDetChamb2(i);
- Ntotal += 6 * 18 * fCalibraMode->GetDetChamb2(i);
- fCalibraMode->ModePadCalibration(0,i);
- fCalibraMode->ModePadFragmentation(0,0,0,i);
- fCalibraMode->SetDetChamb0(i);
- Ntotal += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
- AliInfo(Form("Total number of Xbins: %d",Ntotal));
- return Ntotal;
-
-}
-//____________Set the pad calibration variables for the detector_______________
-Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
-{
- //
- // For the detector calcul the first Xbins and set the number of row
- // and col pads per calibration groups, the number of calibration
- // groups in the detector.
- //
-
- // first Xbins of the detector
- if (fCH2dOn) {
- fCalibraMode->CalculXBins(detector,0);
- }
- if (fPH2dOn) {
- fCalibraMode->CalculXBins(detector,1);
- }
- if (fPRF2dOn) {
- fCalibraMode->CalculXBins(detector,2);
- }
+ ////////////////////////////////
+ // Debug stuff
+ ///////////////////////////////
- // 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)
- , (Int_t) GetSector(detector),i);
- }
-
- return kTRUE;
-}
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::StoreInfoCHPH(AliTRDcluster *cl, AliTRDtrack *t, Int_t *group)
-{
- //
- // Store the infos in fAmpTotal, fPHPlace and fPHValue
- //
-
- // Charge in the cluster
- Float_t q = TMath::Abs(cl->GetQ());
- Int_t time = cl->GetLocalTimeBin();
-
- // Correction due to the track angle
- Float_t correction = 1.0;
- Float_t normalisation = 6.67;
- if ((q >0) && (t->GetNdedx() > 0)) {
- correction = t->GetClusterdQdl((t->GetNdedx() - 1)) / (normalisation);
- }
+ 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
+ }
+
- // Fill the fAmpTotal with the charge
- if (fCH2dOn) {
- fAmpTotal[(Int_t) group[0]] += correction;
- }
+ Int_t layer = GetLayer(fDetectorPreviousTrack);
+
+ (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
+ //"snpright="<<snpright<<
+ "nbli="<<nbli<<
+ "nbclusters="<<nbclusters<<
+ "detector="<<fDetectorPreviousTrack<<
+ "layer="<<layer<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "tnt="<<tnt<<
+ "dydt="<<dydt<<
+ "dzdx="<<dzdx<<
+ "crossrow="<<crossrow<<
+ "errorpar="<<errorpar<<
+ "pointError="<<pointError<<
+ "\n";
- // Fill the fPHPlace and value
- if (fPH2dOn) {
- fPHPlace[time] = group[1];
- fPHValue[time] = correction;
}
-}
-//_____________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliTRDRawStream *rawStream)
-{
- //
- // Event Processing loop - AliTRDRawStream
- //
+ /////////////////////////
+ // Cuts quality
+ ////////////////////////
- Bool_t withInput = kFALSE;
+ if(nbclusters < fNumberClusters) return kFALSE;
+ if(nbclusters > fNumberClustersf) return kFALSE;
+ if(pointError >= 0.3) return kFALSE;
+ if(crossrow == 1) return kFALSE;
+
+ ///////////////////////
+ // Fill
+ //////////////////////
- Int_t phvalue[36];
- //Int_t row[36];
- //Int_t col[36];
- for(Int_t k = 0; k < 36; k++){
- phvalue[k] = 0;
- //row[k] = -1;
- //col[36] = -1;
- }
- fDetectorPreviousTrack = -1;
- Int_t nbtimebin = 0;
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
- if(TMath::Mean(nbtimebin,phvalue)>0.0){
- withInput = kTRUE;
- for(Int_t k = 0; k < nbtimebin; k++){
- UpdateDAQ(fDetectorPreviousTrack,0,0,k,phvalue[k],nbtimebin);
- phvalue[k] = 0;
- //row[k] = -1;
- //col[k] = -1;
- }
+ if(fLinearFitterOn){
+ //Add to the linear fitter of the detector
+ if( TMath::Abs(snp) < 1.){
+ Double_t x = tnp-dzdx*tnt;
+ if(fLinearFitterDebugOn) {
+ (GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
+ fEntriesLinearFitter[fDetectorPreviousTrack]++;
}
- }
- fDetectorPreviousTrack = idetector;
- nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- Int_t iTimeBin = rawStream->GetTimeBin(); // current time bin
- //row[iTimeBin] = rawStream->GetRow(); // current row
- //col[iTimeBin] = rawStream->GetCol(); // current col
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
-
- Int_t fin = TMath::Min(nbtimebin,(iTimeBin+3));
- Int_t n = 0;
- for(Int_t itime = iTimeBin; itime < fin; itime++){
- // should extract baseline here!
- if(signal[n]>5.0) phvalue[itime] = signal[n];
- n++;
+ fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
}
}
- // fill the last one
- if(fDetectorPreviousTrack != -1){
- if(TMath::Mean(nbtimebin,phvalue)>0.0){
- withInput = kTRUE;
- for(Int_t k = 0; k < nbtimebin; k++){
- UpdateDAQ(fDetectorPreviousTrack,0,0,k,phvalue[k],nbtimebin);
- phvalue[k] = 0;
- //row[k] = -1;
- //col[k] = -1;
- }
- }
- }
-
- return withInput;
-
-}
-//_____________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader)
-{
- //
- // Event processing loop - AliRawReader
- //
-
-
- AliTRDRawStream rawStream(rawReader);
-
- rawReader->Select("TRD");
-
- return ProcessEventDAQ(&rawStream);
+ return kTRUE;
}
-//_________________________________________________________________________
-Bool_t AliTRDCalibraFillHisto::ProcessEventDAQ(
-#ifdef ALI_DATE
- eventHeaderStruct *event
-#else
- eventHeaderStruct* /*event*/
-
-#endif
- )
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::HandlePRFtracklet(const AliTRDtrack *t, Int_t index0, Int_t index1)
{
//
- // process date event
- //
-#ifdef ALI_DATE
- AliRawReader *rawReader = new AliRawReaderDate((void*)event);
- Bool_t result=ProcessEventDAQ(rawReader);
- delete rawReader;
- return result;
-#else
- Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
- return 0;
-#endif
-
-}
-//____________Online trackling in AliTRDtrigger________________________________
-Bool_t AliTRDCalibraFillHisto::UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Int_t signal, Int_t nbtimebins)
-{
+ // PRF width calibration
+ // Assume a Gaussian shape: determinate the position of the three pad clusters
+ // Fit with a straight line
+ // Take the fitted values for all the clusters (3 or 2 pad clusters)
+ // Fill the PRF as function of angle of the track
//
- // For the DAQ
- // Fill a simple average pulse height
//
-
- // Localisation of the Xbins involved
- //LocalisationDetectorXbins(det);
- // Row and position in the pad groups
- //Int_t posr = 0;
- //if (fCalibraMode->GetNnZ(1) != 0) {
- // posr = (Int_t) row / fCalibraMode->GetNnZ(1);
- //}
-
- // Col of cluster and position in the pad groups
- //Int_t posc = 0;
- //if (fCalibraMode->GetNnRphi(1) != 0) {
- // posc = (Int_t) col / fCalibraMode->GetNnRphi(1);
- //}
-
- //fPH2d->Fill((Float_t) timebin/fSf,(fCalibraMode->GetXbins(1)+posc*fCalibraMode->GetNfragZ(1)+posr)+0.5,(Float_t) signal);
-
- ((TProfile2D *)GetPH2d(nbtimebins,fSf,kTRUE))->Fill((Float_t) timebin/fSf,det+0.5,(Float_t) signal);
-
- return kTRUE;
-
-}
-//____________Functions for plotting the 2D____________________________________
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::Plot2d()
-{
- //
- // Plot the 2D histos
- //
-
- if (fPH2dOn) {
- TCanvas *cph2d = new TCanvas("cph2d","",50,50,600,800);
- cph2d->cd();
- fPH2d->Draw("LEGO");
- }
- if (fCH2dOn) {
- TCanvas *cch2d = new TCanvas("cch2d","",50,50,600,800);
- cch2d->cd();
- fCH2d->Draw("LEGO");
+ //////////////////////////
+ // variables
+ /////////////////////////
+ Int_t npoints = index1-index0; // number of total points
+ Int_t nb3pc = 0; // number of three pads clusters used for fit
+ Int_t detector = ((AliTRDcluster *) t->GetCluster(index0))->GetDetector(); // detector
+ // To see the difference due to the fit
+ Double_t *padPositions;
+ padPositions = new Double_t[npoints];
+ for(Int_t k = 0; k < npoints; k++){
+ padPositions[k] = 0.0;
+ }
+ // Take the tgl and snp with the track t now
+ 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)*(1.+snp));
+ dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
+ }
+ // linear fitter
+ fLinearFitterTracklet->ClearPoints();
+
+ ///////////////////////////
+ // calcul the tnp group
+ ///////////////////////////
+ Bool_t echec = kFALSE;
+ Double_t shift = 0.0;
+ //Calculate the shift in x coresponding to this tnp
+ if(fNgroupprf != 0.0){
+ shift = -3.0*(fNgroupprf-1)-1.5;
+ Double_t limithigh = -0.2*(fNgroupprf-1);
+ if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
+ else{
+ while(tnp > limithigh){
+ limithigh += 0.2;
+ shift += 3.0;
+ }
+ }
}
- if (fPRF2dOn) {
- TCanvas *cPRF2d = new TCanvas("cPRF2d","",50,50,600,800);
- cPRF2d->cd();
- fPRF2d->Draw("LEGO");
+ if(echec) {
+ delete [] padPositions;
+ return kFALSE;
}
-}
-//_____________________Reset____________________________________________________
-//_______________________________________________________________________________
-void AliTRDCalibraFillHisto::ResetLinearFitter()
-{
- fLinearFitterArray.SetOwner();
- fLinearFitterArray.Clear();
- fLinearFitterHistoArray.SetOwner();
- fLinearFitterHistoArray.Clear();
-}
-//____________Write_____________________________________________________
-//_____________________________________________________________________
-void AliTRDCalibraFillHisto::Write2d(const Char_t *filename, Bool_t append)
-{
- //
- // Write infos to file
- //
+ //////////////////////
+ // loop clusters
+ /////////////////////
+ for(Int_t k = 0; k < npoints; k++){
+ //Take the cluster
+ AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
+ if(!cl) continue;
+ Short_t *signals = cl->GetSignals();
+ Double_t time = cl->GetPadTime();
+ //Calculate x if possible
+ Float_t xcenter = 0.0;
+ Bool_t echec1 = kTRUE;
+ if((time<=7) || (time>=21)) continue;
+ // Center 3 balanced: position with the center of the pad
+ if ((((Float_t) signals[3]) > 0.0) &&
+ (((Float_t) signals[2]) > 0.0) &&
+ (((Float_t) signals[4]) > 0.0)) {
+ echec1 = kFALSE;
+ // Security if the denomiateur is 0
+ if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
+ ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
+ xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
+ / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3])))
+ / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
+ }
+ else {
+ echec1 = kTRUE;
+ }
+ }
+ if(TMath::Abs(xcenter) > 0.5) echec = kTRUE;
+ if(echec) continue;
+ //if no echec: calculate with the position of the pad
+ // Position of the cluster
+ Double_t padPosition = xcenter + cl->GetPadCol();
+ padPositions[k] = padPosition;
+ nb3pc++;
+ fLinearFitterTracklet->AddPoint(&time, padPosition,1);
+ }//clusters loop
- //For debugging
- if ( fDebugStreamer ) {
- delete fDebugStreamer;
- fDebugStreamer = 0x0;
- }
- AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
- ,fNumberTrack
- ,fNumberUsedCh[0]
- ,fNumberUsedCh[1]
- ,fNumberUsedPh[0]
- ,fNumberUsedPh[1]));
+ /////////////////////////////
+ // fit
+ ////////////////////////////
+ if(nb3pc < 3) {
+ delete [] padPositions;
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
+ }
+ fLinearFitterTracklet->Eval();
+ TVectorD line(2);
+ fLinearFitterTracklet->GetParameters(line);
+ Float_t pointError = -1.0;
+ if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+ pointError = TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+ }
+ fLinearFitterTracklet->ClearPoints();
- TDirectory *backup = gDirectory;
- TString option;
+ /////////////////////////////////////////////////////
+ // Now fill the PRF: second loop over clusters
+ /////////////////////////////////////////////////////
+ for(Int_t k = 0; k < npoints; k++){
+ //Take the cluster
+ AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
+ Short_t *signals = cl->GetSignals(); // signal
+ Double_t time = cl->GetPadTime(); // 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
+ Float_t ycenter = 0.0; // relative center charge
+ Float_t ymin = 0.0; // relative left charge
+ Float_t ymax = 0.0; // relative right charge
- if ( append )
- option = "update";
- else
- option = "recreate";
-
- TFile f(filename,option.Data());
-
- TStopwatch stopwatch;
- stopwatch.Start();
-
- if (fCH2dOn ) {
- if (fHisto2d) {
- f.WriteTObject(fCH2d);
- }
- if (fVector2d) {
- TString name("Nz");
- name += fCalibraMode->GetNz(0);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(0);
- TTree *treeCH2d = fCalibraVector->ConvertVectorCTTreeHisto(fCalibraVector->GetVectorCH(),fCalibraVector->GetPlaCH(),"treeCH2d",(const char *) name);
- f.WriteTObject(treeCH2d);
- }
- }
- if (fPH2dOn ) {
- if (fHisto2d) {
- f.WriteTObject(fPH2d);
+ //Requiere simply two pads clusters at least
+ if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
+ ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
+ Float_t sum = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
+ if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
+ if(sum > 0.0) ymin = ((Float_t) signals[2])/ sum;
+ if(sum > 0.0) ymax = ((Float_t) signals[4])/ sum;
}
- if (fVector2d) {
- TString name("Nz");
- name += fCalibraMode->GetNz(1);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(1);
- TTree *treePH2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPH(),fCalibraVector->GetPlaPH(),"treePH2d",(const char *) name);
- f.WriteTObject(treePH2d);
+
+ //calibration group
+ Int_t rowcl = cl->GetPadRow(); // row of cluster
+ Int_t colcl = cl->GetPadCol(); // col of cluster
+ Int_t grouplocal = CalculateCalibrationGroup(2,rowcl,colcl); // calcul the corresponding group
+ 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 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
+ Float_t signal1 = (Float_t)signals[1]; // signal at the border
+ Float_t signal3 = (Float_t)signals[3]; // signal
+ Float_t signal2 = (Float_t)signals[2]; // signal
+ Float_t signal4 = (Float_t)signals[4]; // signal
+ Float_t signal5 = (Float_t)signals[5]; // signal at the border
+
+ //////////////////////////////
+ // debug
+ /////////////////////////////
+ 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
+ }
+
+
+ x = xdiff;
+ Int_t type=0;
+ Float_t y = ycenter;
+ (* fDebugStreamer) << "HandlePRFtracklet"<<
+ "caligroup="<<caligroup<<
+ "detector="<<detector<<
+ "layer="<<layer<<
+ "stack="<< stack <<
+ "npoints="<<npoints<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[k]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+ x=-(xdiff+1);
+ y = ymin;
+ type=-1;
+ (* fDebugStreamer) << "HandlePRFtracklet"<<
+ "caligroup="<<caligroup<<
+ "detector="<<detector<<
+ "layer="<<layer<<
+ "stack="<<stack<<
+ "npoints="<<npoints<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[k]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+ x=1-xdiff;
+ y = ymax;
+ type=1;
+ (* fDebugStreamer) << "HandlePRFtracklet"<<
+ "caligroup="<<caligroup<<
+ "detector="<<detector<<
+ "layer="<<layer<<
+ "stack="<<stack<<
+ "npoints="<<npoints<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[k]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+
}
- }
- if (fPRF2dOn) {
+
+ ////////////////////////////
+ // quality cuts
+ ///////////////////////////
+ if(npoints < fNumberClusters) continue;
+ if(npoints > fNumberClustersf) continue;
+ if(nb3pc <= 5) continue;
+ if((time >= 21) || (time < 7)) continue;
+ if(TMath::Abs(snp) >= 1.0) continue;
+ if(TMath::Abs(qcl) < 80) continue;
+
+ ////////////////////////////
+ // Fill
+ ///////////////////////////
if (fHisto2d) {
- f.WriteTObject(fPRF2d);
+ if(TMath::Abs(dpad) < 1.5) {
+ fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
+ fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
+ }
+ if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+ fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
+ fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
+ }
+ if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+ fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
+ fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
+ }
}
if (fVector2d) {
- TString name("Nz");
- name += fCalibraMode->GetNz(2);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(2);
- name += "Ngp";
- name += fNgroupprf;
- TTree *treePRF2d = fCalibraVector->ConvertVectorPTreeHisto(fCalibraVector->GetVectorPRF(),fCalibraVector->GetPlaPRF(),"treePRF2d",(const char *) name);
- f.WriteTObject(treePRF2d);
+ if(TMath::Abs(dpad) < 1.5) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
+ }
+ if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
+ }
+ if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
+ }
}
}
- if(fLinearFitterOn && fLinearFitterDebugOn){
- f.WriteTObject(&fLinearFitterHistoArray);
- }
-
- f.Close();
-
- if ( backup ) backup->cd();
+ delete [] padPositions;
+ return kTRUE;
- AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
- ,stopwatch.RealTime(),stopwatch.CpuTime()));
}
-//___________________________________________probe the histos__________________________________________________
-Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
+//____________Offine tracking in the AliTRDtracker_____________________________
+Bool_t AliTRDCalibraFillHisto::HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters)
{
//
- // Check the number of stats in h, 0 is TH2I 1 is TProfile2D
- // debug mode with 2 for TH2I and 3 for TProfile2D
- // It gives a pointer to a Double_t[7] with the info following...
- // [0] : number of calibration groups with entries
- // [1] : minimal number of entries found
- // [2] : calibration group number of the min
- // [3] : maximal number of entries found
- // [4] : calibration group number of the max
- // [5] : mean number of entries found
- // [6] : mean relativ error
+ // PRF width calibration
+ // Assume a Gaussian shape: determinate the position of the three pad clusters
+ // Fit with a straight line
+ // Take the fitted values for all the clusters (3 or 2 pad clusters)
+ // Fill the PRF as function of angle of the track
+ //
//
- Double_t *info = new Double_t[7];
-
- // Number of Xbins (detectors or groups of pads)
- Int_t nbins = h->GetNbinsY(); //number of calibration groups
- Int_t nxbins = h->GetNbinsX(); //number of bins per histo
-
- // Initialise
- Double_t nbwe = 0; //number of calibration groups with entries
- Double_t minentries = 0; //minimal number of entries found
- Double_t maxentries = 0; //maximal number of entries found
- Double_t placemin = 0; //calibration group number of the min
- Double_t placemax = -1; //calibration group number of the max
- Double_t meanstats = 0.0; //mean number of entries over the calibration group with at least ome entry
- Double_t meanrelativerror = 0.0; //mean relativ error in the TProfile2D
-
- Double_t counter = 0;
-
- //Debug
- TH1F *NbEntries = 0x0;//distribution of the number of entries
- TH1F *NbEntriesPerGroup = 0x0;//Number of entries per group
- TProfile *NbEntriesPerSp = 0x0;//Number of entries for one supermodule
-
- // Beginning of the loop over the calibration groups
- for (Int_t idect = 0; idect < nbins; idect++) {
-
- TH1I *projch = (TH1I *) h->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
- projch->SetDirectory(0);
-
- // Number of entries for this calibration group
- Double_t nentries = 0.0;
- if((i%2) == 0){
- for (Int_t k = 0; k < nxbins; k++) {
- nentries += h->GetBinContent(h->GetBin(k+1,idect+1));
- }
- }
+ //printf("begin\n");
+ ///////////////////////////////////////////
+ // Take the parameters of the track
+ //////////////////////////////////////////
+ // take now the snp, tnp and tgl from 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)*(1.+snp));
+ }
+ Double_t tgl = tracklet->GetTgl(); // dz/dl
+ Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
+ // at the entrance
+ //Double_t tnp = tracklet->GetYref(1); // dy/dx at the entrance of the chamber
+ //Double_t tgl = tracklet->GetZref(1); // dz/dl at the entrance of the chamber
+ //Double_t dzdx = tgl; //*TMath::Sqrt(1+tnp*tnp); // dz/dx from dz/dl
+ // at the end with correction due to linear fit
+ //Double_t tnp = tracklet->GetYfit(1); // dy/dx at the end of the chamber after fit correction
+ //Double_t tgl = tracklet->GetZfit(1); // dz/dl at the end of the chamber after fit correction
+
+ ///////////////////////////////
+ // Calculate tnp group shift
+ ///////////////////////////////
+ Bool_t echec = kFALSE;
+ Double_t shift = 0.0;
+ //Calculate the shift in x coresponding to this tnp
+ if(fNgroupprf != 0.0){
+ shift = -3.0*(fNgroupprf-1)-1.5;
+ Double_t limithigh = -0.2*(fNgroupprf-1);
+ if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
else{
- for (Int_t k = 0; k < nxbins; k++) {
- nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(k+1,idect+1));
- if(h->GetBinContent(h->GetBin(k+1,idect+1)) != 0) {
- meanrelativerror += (h->GetBinError(h->GetBin(k+1,idect+1))/(TMath::Abs(h->GetBinContent(h->GetBin(k+1,idect+1)))));
- counter++;
- }
+ while(tnp > limithigh){
+ limithigh += 0.2;
+ shift += 3.0;
}
}
+ }
+ // do nothing if out of tnp range
+ //printf("echec %d\n",(Int_t)echec);
+ if(echec) return kFALSE;
- //Debug
- if(i > 1){
- if((!((Bool_t)NbEntries)) && (nentries > 0)){
- NbEntries = new TH1F("Number of entries","Number of entries"
- ,100,(Int_t)nentries/2,nentries*2);
- NbEntries->SetDirectory(0);
- NbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
- ,nbins,0,nbins);
- NbEntriesPerGroup->SetDirectory(0);
- NbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
- ,(Int_t)(nbins/18),0,(Int_t)(nbins/18));
- NbEntriesPerSp->SetDirectory(0);
+ ///////////////////////
+ // Variables
+ //////////////////////
+
+ Int_t nb3pc = 0; // number of three pads clusters used for fit
+ // to see the difference between the fit and the 3 pad clusters position
+ Double_t padPositions[AliTRDseedV1::kNtb];
+ memset(padPositions, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
+ fLinearFitterTracklet->ClearPoints();
+
+ //printf("loop clusters \n");
+ ////////////////////////////
+ // loop over the clusters
+ ////////////////////////////
+ AliTRDcluster *cl = 0x0;
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
+ // reject shared clusters on pad row
+ if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
+ if((cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) continue;
+ }
+ if(!(cl = tracklet->GetClusters(ic))) continue;
+ Double_t time = cl->GetPadTime();
+ if((time<=7) || (time>=21)) continue;
+ Short_t *signals = cl->GetSignals();
+ Float_t xcenter = 0.0;
+ Bool_t echec1 = kTRUE;
+
+ /////////////////////////////////////////////////////////////
+ // Center 3 balanced: position with the center of the pad
+ /////////////////////////////////////////////////////////////
+ if ((((Float_t) signals[3]) > 0.0) &&
+ (((Float_t) signals[2]) > 0.0) &&
+ (((Float_t) signals[4]) > 0.0)) {
+ echec1 = kFALSE;
+ // Security if the denomiateur is 0
+ if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
+ ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
+ xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
+ / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3])))
+ / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
}
- if(NbEntries){
- if(nentries > 0) NbEntries->Fill(nentries);
- NbEntriesPerGroup->Fill(idect+0.5,nentries);
- NbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
+ else {
+ echec1 = kTRUE;
}
}
+ if(TMath::Abs(xcenter) > 0.5) echec1 = kTRUE;
+ if(echec1) continue;
- //min amd max
- if(nentries > maxentries){
- maxentries = nentries;
- placemax = idect;
- }
- if(idect == 0) {
- minentries = nentries;
- }
- if(nentries < minentries){
- minentries = nentries;
- placemin = idect;
- }
- //nbwe
- if(nentries > 0) {
- nbwe++;
- meanstats += nentries;
- }
- }//calibration groups loop
-
- if(nbwe > 0) meanstats /= nbwe;
- if(counter > 0) meanrelativerror /= counter;
+ ////////////////////////////////////////////////////////
+ //if no echec1: calculate with the position of the pad
+ // Position of the cluster
+ // fill the linear fitter
+ ///////////////////////////////////////////////////////
+ Double_t padPosition = xcenter + cl->GetPadCol();
+ padPositions[ic] = padPosition;
+ nb3pc++;
+ fLinearFitterTracklet->AddPoint(&time, padPosition,1);
- AliInfo(Form("There are %f calibration groups with entries",nbwe));
- AliInfo(Form("The minimum number of entries is %f for the group %f",minentries,placemin));
- AliInfo(Form("The maximum number of entries is %f for the group %f",maxentries,placemax));
- AliInfo(Form("The mean number of entries is %f",meanstats));
- if((i%2) == 1) AliInfo(Form("The mean relative error is %f",meanrelativerror));
- info[0] = nbwe;
- info[1] = minentries;
- info[2] = placemin;
- info[3] = maxentries;
- info[4] = placemax;
- info[5] = meanstats;
- info[6] = meanrelativerror;
+ }//clusters loop
- if(i > 1){
- gStyle->SetPalette(1);
- gStyle->SetOptStat(1111);
- gStyle->SetPadBorderMode(0);
- gStyle->SetCanvasColor(10);
- gStyle->SetPadLeftMargin(0.13);
- gStyle->SetPadRightMargin(0.01);
- TCanvas *stat = new TCanvas("stat","",50,50,600,800);
- stat->Divide(2,1);
- stat->cd(1);
- NbEntries->Draw("");
- stat->cd(2);
- NbEntriesPerSp->SetStats(0);
- NbEntriesPerSp->Draw("");
- TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
- stat1->cd();
- NbEntriesPerGroup->SetStats(0);
- NbEntriesPerGroup->Draw("");
+ //printf("Fin loop clusters \n");
+ //////////////////////////////
+ // fit with a straight line
+ /////////////////////////////
+ if(nb3pc < 3){
+ fLinearFitterTracklet->ClearPoints();
+ return kFALSE;
}
-
- return info;
-
-}
-//____________________________________________________________________________
-Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberCH()
-{
- //
- // Return a Int_t[4] with:
- // 0 Mean number of entries
- // 1 median of number of entries
- // 2 rms of number of entries
- // 3 number of group with entries
- //
-
- Double_t *stat = new Double_t[4];
- stat[3] = 0.0;
-
- Int_t nbofgroups = CalculateTotalNumberOfBins(0);
- Double_t *weight = new Double_t[nbofgroups];
- Int_t *nonul = new Int_t[nbofgroups];
+ fLinearFitterTracklet->Eval();
+ TVectorD line(2);
+ fLinearFitterTracklet->GetParameters(line);
+ Float_t pointError = -1.0;
+ if( fLinearFitterTracklet->GetChisquare()>=0.0) {
+ pointError = TMath::Sqrt( fLinearFitterTracklet->GetChisquare()/(nb3pc-2));
+ }
+ fLinearFitterTracklet->ClearPoints();
- for(Int_t k = 0; k < nbofgroups; k++){
- if(fEntriesCH[k] > 0) {
- weight[k] = 1.0;
- nonul[(Int_t)stat[3]] = fEntriesCH[k];
- stat[3]++;
+ //printf("PRF second loop \n");
+ ////////////////////////////////////////////////
+ // Fill the PRF: Second loop over clusters
+ //////////////////////////////////////////////
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
+ // reject shared clusters on pad row
+ if(((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) && (cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) continue;
+ //
+ if(!(cl = tracklet->GetClusters(ic))) continue;
+
+ Short_t *signals = cl->GetSignals(); // signal
+ Double_t time = cl->GetPadTime(); // 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
+ Float_t ycenter = 0.0; // relative center charge
+ Float_t ymin = 0.0; // relative left charge
+ Float_t ymax = 0.0; // relative right charge
+
+ ////////////////////////////////////////////////////////////////
+ // Calculate ycenter, ymin and ymax even for two pad clusters
+ ////////////////////////////////////////////////////////////////
+ if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
+ ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
+ Float_t sum = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
+ if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
+ if(sum > 0.0) ymin = ((Float_t) signals[2])/ sum;
+ if(sum > 0.0) ymax = ((Float_t) signals[4])/ sum;
}
- else weight[k] = 0.0;
- }
- stat[0] = TMath::Mean(nbofgroups,fEntriesCH,weight);
- stat[1] = TMath::Median(nbofgroups,fEntriesCH,weight);
- stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+
+ /////////////////////////
+ // Calibration group
+ ////////////////////////
+ Int_t rowcl = cl->GetPadRow(); // row of cluster
+ Int_t colcl = cl->GetPadCol(); // col of cluster
+ Int_t grouplocal = CalculateCalibrationGroup(2,rowcl,colcl); // calcul the corresponding group
+ 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 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 signal1 = (Float_t)signals[1]; // signal at the border
+ Float_t signal3 = (Float_t)signals[3]; // signal
+ Float_t signal2 = (Float_t)signals[2]; // signal
+ Float_t signal4 = (Float_t)signals[4]; // signal
+ Float_t signal5 = (Float_t)signals[5]; // signal at the border
+
- return stat;
-}
-//____________________________________________________________________________
-Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberLinearFitter() const
-{
- //
- // Return a Int_t[4] with:
- // 0 Mean number of entries
- // 1 median of number of entries
- // 2 rms of number of entries
- // 3 number of group with entries
- //
+ /////////////////////
+ // Debug stuff
+ ////////////////////
- Double_t *stat = new Double_t[4];
- stat[3] = 0.0;
+ 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
+ }
+
+ x = xdiff;
+ Int_t type=0;
+ Float_t y = ycenter;
+ (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+ "caligroup="<<caligroup<<
+ "detector="<<fDetectorPreviousTrack<<
+ "layer="<<layer<<
+ "stack="<<stack<<
+ "npoints="<<nbclusters<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[ic]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+ x=-(xdiff+1);
+ y = ymin;
+ type=-1;
+ (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+ "caligroup="<<caligroup<<
+ "detector="<<fDetectorPreviousTrack<<
+ "layer="<<layer<<
+ "stack="<<stack<<
+ "npoints="<<nbclusters<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[ic]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+ x=1-xdiff;
+ y = ymax;
+ type=1;
+ (* fDebugStreamer) << "HandlePRFtrackletV1"<<
+ "caligroup="<<caligroup<<
+ "detector="<<fDetectorPreviousTrack<<
+ "layer="<<layer<<
+ "stack="<<stack<<
+ "npoints="<<nbclusters<<
+ "Np="<<nb3pc<<
+ "ep="<<ep<<
+ "type="<<type<<
+ "snp="<<snp<<
+ "tnp="<<tnp<<
+ "tgl="<<tgl<<
+ "dzdx="<<dzdx<<
+ "padPos="<<padPos<<
+ "padPosition="<<padPositions[ic]<<
+ "padPosTracklet="<<padPosTracklet<<
+ "x="<<x<<
+ "y="<<y<<
+ "xcl="<<xcl<<
+ "qcl="<<qcl<<
+ "signal1="<<signal1<<
+ "signal2="<<signal2<<
+ "signal3="<<signal3<<
+ "signal4="<<signal4<<
+ "signal5="<<signal5<<
+ "time="<<time<<
+ "\n";
+
+ }
+
+ /////////////////////
+ // Cuts quality
+ /////////////////////
+ if(nbclusters < fNumberClusters) continue;
+ if(nbclusters > fNumberClustersf) continue;
+ if(nb3pc <= 5) continue;
+ if((time >= 21) || (time < 7)) continue;
+ if(TMath::Abs(qcl) < 80) continue;
+ if( TMath::Abs(snp) > 1.) continue;
- Int_t nbofgroups = 540;
- Double_t *weight = new Double_t[nbofgroups];
- Int_t *nonul = new Int_t[nbofgroups];
- for(Int_t k = 0; k < nbofgroups; k++){
- if(fEntriesLinearFitter[k] > 0) {
- weight[k] = 1.0;
- nonul[(Int_t) stat[3]] = fEntriesLinearFitter[k];
- stat[3]++;
+ ////////////////////////
+ // Fill the histos
+ ///////////////////////
+ if (fHisto2d) {
+ if(TMath::Abs(dpad) < 1.5) {
+ fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
+ fPRF2d->Fill(shift-dpad,(caligroup+0.5),ycenter);
+ //printf("place %f, ycenter %f\n",(shift+dpad),ycenter);
+ }
+ if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+ fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
+ fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
+ }
+ if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+ fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
+ fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
+ }
}
- else weight[k] = 0.0;
- }
- stat[0] = TMath::Mean(nbofgroups,fEntriesLinearFitter,weight);
- stat[1] = TMath::Median(nbofgroups,fEntriesLinearFitter,weight);
- stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+ // vector method
+ if (fVector2d) {
+ if(TMath::Abs(dpad) < 1.5) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+dpad,ycenter);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-dpad,ycenter);
+ }
+ if((ymin > 0.0) && (TMath::Abs(dpad+1.0) < 1.5)) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-(dpad+1.0),ymin);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+(dpad+1.0),ymin);
+ }
+ if((ymax > 0.0) && (TMath::Abs(dpad-1.0) < 1.5)) {
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift+1.0-dpad,ymax);
+ fCalibraVector->UpdateVectorPRF(fDetectorPreviousTrack,grouplocal,shift-1.0+dpad,ymax);
+ }
+ }
+ } // second loop over clusters
- return stat;
+ return kTRUE;
}
+///////////////////////////////////////////////////////////////////////////////////////
+// Pad row col stuff: see if masked or not
+///////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
+void AliTRDCalibraFillHisto::CheckGoodTrackletV1(const AliTRDcluster *cl)
{
//
- // Should be between 0 and 6
+ // See if we are not near a masked pad
//
-
- if ((numberGroupsPRF < 0) || (numberGroupsPRF > 6)) {
- AliInfo("The number of groups must be between 0 and 6!");
- }
- else {
- fNgroupprf = numberGroupsPRF;
- }
-}
+ if(cl->IsMasked()) fGoodTracklet = kFALSE;
+
+
+}
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
+void AliTRDCalibraFillHisto::CheckGoodTrackletV0(const Int_t detector,const Int_t row,const Int_t col)
{
//
- // Set the factor that will divide the deposited charge
- // to fit in the histo range [0,300]
+ // See if we are not near a masked pad
//
-
- if (RelativeScale > 0.0) {
- fRelativeScale = RelativeScale;
- }
- else {
- AliInfo("RelativeScale must be strict positif!");
+
+ if (!IsPadOn(detector, col, row)) {
+ fGoodTracklet = kFALSE;
}
-}
+ if (col > 0) {
+ if (!IsPadOn(detector, col-1, row)) {
+ fGoodTracklet = kFALSE;
+ }
+ }
+ if (col < 143) {
+ if (!IsPadOn(detector, col+1, row)) {
+ fGoodTracklet = kFALSE;
+ }
+ }
+
+}
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
+Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t row, Int_t col) const
{
//
- // Set the mode of calibration group in the z direction for the parameter i
- //
+ // Look in the choosen database if the pad is On.
+ // If no the track will be "not good"
+ //
- if ((Nz >= 0) &&
- (Nz < 5)) {
- fCalibraMode->SetNz(i, Nz);
+ // Get the parameter object
+ AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ if (!cal) {
+ AliInfo("Could not get calibDB");
+ return kFALSE;
}
- else {
- AliInfo("You have to choose between 0 and 4");
+
+ if (!cal->IsChamberInstalled(detector) ||
+ cal->IsChamberMasked(detector) ||
+ cal->IsPadMasked(detector,col,row)) {
+ return kFALSE;
}
-
+ else {
+ return kTRUE;
+ }
+
}
-
+///////////////////////////////////////////////////////////////////////////////////////
+// Calibration groups: calculate the number of groups, localise...
+////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
+Int_t AliTRDCalibraFillHisto::CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
{
//
- // Set the mode of calibration group in the rphi direction for the parameter i
+ // Calculate the calibration group number for i
//
- if ((Nrphi >= 0) &&
- (Nrphi < 7)) {
- fCalibraMode->SetNrphi(i ,Nrphi);
+ // Row of the cluster and position in the pad groups
+ Int_t posr = 0;
+ if (fCalibraMode->GetNnZ(i) != 0) {
+ posr = (Int_t) row / fCalibraMode->GetNnZ(i);
+ }
+
+
+ // Col of the cluster and position in the pad groups
+ Int_t posc = 0;
+ if (fCalibraMode->GetNnRphi(i) != 0) {
+ posc = (Int_t) col / fCalibraMode->GetNnRphi(i);
+ }
+
+ return posc*fCalibraMode->GetNfragZ(i)+posr;
+
+}
+//____________________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
+{
+ //
+ // Calculate the total number of calibration groups
+ //
+
+ 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);
+ ntotal += 6 * 18 * fCalibraMode->GetDetChamb2(i);
+ fCalibraMode->ModePadCalibration(0,i);
+ fCalibraMode->ModePadFragmentation(0,0,0,i);
+ fCalibraMode->SetDetChamb0(i);
+ ntotal += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(i);
+ AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+ return ntotal;
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNz(Int_t i, Short_t Nz)
+{
+ //
+ // Set the mode of calibration group in the z direction for the parameter i
+ //
+
+ if ((Nz >= 0) &&
+ (Nz < 5)) {
+ fCalibraMode->SetNz(i, Nz);
+ }
+ else {
+ AliInfo("You have to choose between 0 and 4");
+ }
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
+{
+ //
+ // Set the mode of calibration group in the rphi direction for the parameter i
+ //
+
+ if ((Nrphi >= 0) &&
+ (Nrphi < 7)) {
+ fCalibraMode->SetNrphi(i ,Nrphi);
}
else {
AliInfo("You have to choose between 0 and 6");
}
}
-//____________Protected Functions______________________________________________
-//____________Create the 2D histo to be filled online__________________________
-//
+
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
+void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
{
//
- // Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
- // If fNgroupprf is zero then no binning in tnp
+ // Set the mode of calibration group all together
//
+ if(fVector2d == kTRUE) {
+ AliInfo("Can not work with the vector method");
+ return;
+ }
+ fCalibraMode->SetAllTogether(i);
+
+}
- TString name("Nz");
- name += fCalibraMode->GetNz(2);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(2);
- name += "Ngp";
- name += fNgroupprf;
+//_____________________________________________________________________________
+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);
+
+}
- if(fNgroupprf != 0){
-
- fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
- ,2*fNgroupprf*fNumberBinPRF,-3.0*fNgroupprf,3.0*fNgroupprf,nn,0,nn);
- fPRF2d->SetYTitle("Det/pad groups");
- fPRF2d->SetXTitle("Position x/W [pad width units]");
- fPRF2d->SetZTitle("Q_{i}/Q_{total}");
- fPRF2d->SetStats(0);
+//____________Set the pad calibration variables for the detector_______________
+Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
+{
+ //
+ // For the detector calcul the first Xbins and set the number of row
+ // and col pads per calibration groups, the number of calibration
+ // groups in the detector.
+ //
+
+ // first Xbins of the detector
+ if (fCH2dOn) {
+ fCalibraMode->CalculXBins(detector,0);
}
- else{
- fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
- ,fNumberBinPRF,-1.5,1.5,nn,0,nn);
- fPRF2d->SetYTitle("Det/pad groups");
- fPRF2d->SetXTitle("Position x/W [pad width units]");
- fPRF2d->SetZTitle("Q_{i}/Q_{total}");
- fPRF2d->SetStats(0);
+ if (fPH2dOn) {
+ fCalibraMode->CalculXBins(detector,1);
+ }
+ if (fPRF2dOn) {
+ fCalibraMode->CalculXBins(detector,2);
}
+ // fragmentation of idect
+ for (Int_t i = 0; i < 3; i++) {
+ fCalibraMode->ModePadCalibration((Int_t) GetStack(detector),i);
+ fCalibraMode->ModePadFragmentation((Int_t) GetLayer(detector)
+ , (Int_t) GetStack(detector)
+ , (Int_t) GetSector(detector),i);
+ }
+
+ return kTRUE;
+
}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetNumberGroupsPRF(Short_t numberGroupsPRF)
+{
+ //
+ // Should be between 0 and 6
+ //
+
+ if ((numberGroupsPRF < 0) || (numberGroupsPRF > 6)) {
+ AliInfo("The number of groups must be between 0 and 6!");
+ }
+ else {
+ fNgroupprf = numberGroupsPRF;
+ }
+}
+///////////////////////////////////////////////////////////////////////////////////////////
+// Per tracklet: store or reset the info, fill the histos with the info
+//////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
+void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col)
{
//
- // Create the 2D histos
+ // Store the infos in fAmpTotal, fPHPlace and fPHValue
+ // Correct from the gain correction before
//
+
+ // time bin of the cluster not corrected
+ Int_t time = cl->GetPadTime();
+ Float_t charge = TMath::Abs(cl->GetQ());
- TString name("Nz");
- name += fCalibraMode->GetNz(1);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(1);
+ //printf("Store::time %d, amplitude %f\n",time,dqdl);
- fPH2d = new TProfile2D("PH2d",(const Char_t *) name
- ,fTimeMax,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf
- ,nn,0,nn);
- fPH2d->SetYTitle("Det/pad groups");
- fPH2d->SetXTitle("time [#mus]");
- fPH2d->SetZTitle("<PH> [a.u.]");
- fPH2d->SetStats(0);
+ //Correct for the gain coefficient used in the database for reconstruction
+ 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( correctthegain > 0 ) normalisation /= correctthegain;
-}
-//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
+ // take dd/dl corrected from the angle of the track
+ correction = dqdl / (normalisation);
+
+
+ // Fill the fAmpTotal with the charge
+ if (fCH2dOn) {
+ if((!fLimitChargeIntegration) || (cl->IsInChamber())) {
+ //printf("Store::group %d, amplitude %f\n",group[0],correction);
+ fAmpTotal[(Int_t) group[0]] += correction;
+ }
+ }
+
+ // Fill the fPHPlace and value
+ if (fPH2dOn) {
+ fPHPlace[time] = group[1];
+ fPHValue[time] = charge;
+ }
+
+}
+//____________Offine tracking in the AliTRDtracker_____________________________
+void AliTRDCalibraFillHisto::ResetfVariablestracklet()
{
//
- // Create the 2D histos
+ // Reset values per tracklet
//
- TString name("Nz");
- name += fCalibraMode->GetNz(0);
- name += "Nrphi";
- name += fCalibraMode->GetNrphi(0);
+ //Reset good tracklet
+ fGoodTracklet = kTRUE;
- fCH2d = new TH2I("CH2d",(const Char_t *) name
- ,fNumberBinCharge,0,300,nn,0,nn);
- fCH2d->SetYTitle("Det/pad groups");
- fCH2d->SetXTitle("charge deposit [a.u]");
- fCH2d->SetZTitle("counts");
- fCH2d->SetStats(0);
- fCH2d->Sumw2();
+ // Reset the fPHValue
+ if (fPH2dOn) {
+ //Reset the fPHValue and fPHPlace
+ for (Int_t k = 0; k < fTimeMax; k++) {
+ fPHValue[k] = 0.0;
+ fPHPlace[k] = -1;
+ }
+ }
+ // Reset the fAmpTotal where we put value
+ if (fCH2dOn) {
+ for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
+ fAmpTotal[k] = 0.0;
+ }
+ }
}
//____________Offine tracking in the AliTRDtracker_____________________________
-void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH()
+void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
{
//
// For the offline tracking or mcm tracklets
Int_t nb = 0; // Nombre de zones traversees
Int_t fd = -1; // Premiere zone non nulle
Float_t totalcharge = 0.0; // Total charge for the supermodule histo
-
+
+ //printf("CH2d nbclusters %d, fNumberClusters %d, fNumberClustersf %d\n",nbclusters,fNumberClusters,fNumberClustersf);
+
+ if(nbclusters < fNumberClusters) return;
+ if(nbclusters > fNumberClustersf) return;
+
+
+ // Normalize with the number of clusters
+ Double_t normalizeCst = fRelativeScale;
+ if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;
+
+ //printf("Number of groups in one detector %d\n",fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0));
// See if the track goes through different zones
for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
+ //printf("fAmpTotal %f for %d\n",fAmpTotal[k],k);
if (fAmpTotal[k] > 0.0) {
totalcharge += fAmpTotal[k];
nb++;
}
}
-
+ //printf("CH2d: nb %d, fd %d, calibration group %d, amplitude %f, detector %d\n",nb,fd,fCalibraMode->GetXbins(0),fAmpTotal[fd]/normalizeCst,fDetectorPreviousTrack);
+
switch (nb)
{
case 1:
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(fCalibraMode->GetXbins(0)+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(fCalibraMode->GetXbins(0)+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(fCalibraMode->GetXbins(0)+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(fCalibraMode->GetXbins(0)+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(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
}
}
}
Int_t fd2 = -1; // Deuxieme zone non nulle
Int_t k1 = -1; // Debut de la premiere zone
Int_t k2 = -1; // Debut de la seconde zone
+ Int_t nbclusters = 0; // number of clusters
+
+
// See if the track goes through different zones
for (Int_t k = 0; k < fTimeMax; k++) {
if (fPHValue[k] > 0.0) {
+ nbclusters++;
if (fd1 == -1) {
fd1 = fPHPlace[k];
k1 = k;
}
}
+ // 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;
+
switch(nb)
{
case 1:
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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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((fCalibraMode->GetXbins(1)+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]);
+ }
}
}
}
default: break;
}
}
-//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::FindP1TrackPH()
+//////////////////////////////////////////////////////////////////////////////////////////
+// DAQ process functions
+/////////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
{
//
- // For the offline tracking
- // This function will be called in the functions UpdateHistogram...
- // to fill the find the parameter P1 of a track for the drift velocity calibration
+ // Event Processing loop - AliTRDrawStreamBase
+ // TestBeam 2007 version
+ // 0 timebin problem
+ // 1 no input
+ // 2 input
+ // Same algorithm as TestBeam but different reader
//
+
+ rawStream->SetSharedPadReadout(kFALSE);
- //Number of points: if less than 3 return kFALSE
- Int_t Npoints = fListClusters->GetEntriesFast();
- if(Npoints <= 2) return kFALSE;
+ Int_t withInput = 1;
+
+ Double_t phvalue[16][144][36];
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+
+ fDetectorPreviousTrack = -1;
+ fMCMPrevious = -1;
+ fROBPrevious = -1;
+ Int_t nbtimebin = 0;
+ Int_t baseline = 10;
- //Variables
- TLinearFitter linearFitterTracklet = TLinearFitter(2,"pol1"); // TLinearFitter per tracklet
- Double_t snp = 0.0; // sin angle in the plan yx track
- Double_t y = 0.0; // y clusters in the middle of the chamber
- Double_t z = 0.0; // z cluster in the middle of the chamber
- Double_t dydt = 0.0; // dydt tracklet after straight line fit
- Double_t tnp = 0.0; // tan angle in the plan xy track
- Double_t tgl = 0.0; // dz/dl and not dz/dx!
- 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 detector = ((AliTRDcluster *) fListClusters->At(0))->GetDetector(); //detector
- Int_t snpright = 1; // if we took in the middle snp
- Int_t crossrow = 0; // if it crosses a pad row
- Double_t tiltingangle = 0; // tiltingangle of the pad
- Float_t dzdx = 0; // dz/dx now from dz/dl
- Int_t nbli = 0; // number linear fitter points
- AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetPlane(detector),GetChamber(detector));
- linearFitterTracklet.StoreData(kFALSE);
- linearFitterTracklet.ClearPoints();
+ if(!nocheck){
- //if more than one row
- Int_t rowp = -1; // if it crosses a pad row
+ 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
- //tiltingangle
- tiltingangle = padplane->GetTiltingAngle();
- Float_t tnt = TMath::Tan(tiltingangle/180.*TMath::Pi()); // tan tiltingangle
+ //printf("Detector %d\n",idetector);
- //Fill with points
- for(Int_t k = 0; k < Npoints; k++){
-
- AliTRDcluster *cl = (AliTRDcluster *) fListClusters->At(k);
- Double_t ycluster = cl->GetY();
- Int_t time = cl->GetLocalTimeBin();
- Double_t timeis = time/fSf;
- //See if cross two pad rows
- Int_t row = padplane->GetPadRowNumber(cl->GetZ());
- if(k==0) rowp = row;
- if(row != rowp) crossrow = 1;
- //Take in the middle of the chamber
- if(time > (Int_t) 10) {
- z = cl->GetZ();
- y = cl->GetY();
- snp = fPar2[time];
- tgl = fPar3[time];
- }
- linearFitterTracklet.AddPoint(&timeis,ycluster,1);
- nbli++;
- }
- if(((AliTRDcluster *) fListClusters->At(0))->GetLocalTimeBin() <= 10) snpright = 0;
- if(nbli <= 2) return kFALSE;
-
- // Do the straight line fit now
- TVectorD pars;
- linearFitterTracklet.Eval();
- linearFitterTracklet.GetParameters(pars);
- pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/nbli);
- errorpar = linearFitterTracklet.GetParError(1)*pointError;
- dydt = pars[1];
-
- if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
- }
- dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
+ if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
+
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
+
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+ }
+
+ 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;
+
+ //baseline = rawStream->GetCommonAdditive(); // common additive baseline
+ fNumberClustersf = fTimeMax;
+ fNumberClusters = (Int_t)(0.6*fTimeMax);
+
+
+ Int_t *signal = rawStream->GetSignals(); // current ADC signal
+ Int_t col = rawStream->GetCol();
+ Int_t row = rawStream->GetRow();
+
+
+ //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++){
+ phvalue[row][col][itime] = signal[itime]-baseline;
+ }
+ }
+
+ // fill the last one
+ if(fDetectorPreviousTrack != -1){
+
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
+
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+ }
+
+ }
+ 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
+
+ //printf("Detector %d\n",idetector);
+
+ if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
+
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
+
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+ }
+
+ 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);
+ Int_t *signal = rawStream->GetSignals(); // current ADC signal
+ Int_t col = rawStream->GetCol();
+ Int_t row = rawStream->GetRow();
+
+
+ //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++){
+ phvalue[row][col][itime] = signal[itime]-baseline;
+ }
+ }
+
+ // fill the last one
+ if(fDetectorPreviousTrack != -1){
+
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
+
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+ }
+ }
+
+ return withInput;
+
+}
+//_____________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck)
+{
+ //
+ // Event processing loop - AliRawReader
+ // Testbeam 2007 version
+ //
+
+ AliTRDrawStreamBase rawStream(rawReader);
+
+ rawReader->Select("TRD");
+
+ return ProcessEventDAQ(&rawStream, nocheck);
+}
+
+//_________________________________________________________________________
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(
+#ifdef ALI_DATE
+ const eventHeaderStruct *event,
+ Bool_t nocheck
+#else
+ const eventHeaderStruct* /*event*/,
+ Bool_t /*nocheck*/
+
+#endif
+ )
+{
+ //
+ // process date event
+ // Testbeam 2007 version
+ //
+#ifdef ALI_DATE
+ AliRawReader *rawReader = new AliRawReaderDate((void*)event);
+ Int_t result=ProcessEventDAQ(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(Double_t phvalue[16][144][36]){
+
+ //
+ // Look for the maximum by collapsing over the time
+ // Sum over four pad col and two pad row
+ //
+
+ Int_t used = 0;
+
+
+ Int_t idect = fDetectorPreviousTrack;
+ //printf("Enter Detector %d\n",fDetectorPreviousTrack);
+ Double_t sum[36];
+ for(Int_t tb = 0; tb < 36; tb++){
+ sum[tb] = 0.0;
+ }
+
+ //fGoodTracklet = kTRUE;
+ //fDetectorPreviousTrack = 0;
+
+
+ ///////////////////////////
+ // look for maximum
+ /////////////////////////
+
+ Int_t imaxRow = 0;
+ Int_t imaxCol = 0;
+ Double_t integralMax = -1;
+
+ for (Int_t ir = 1; ir <= 15; ir++)
+ {
+ for (Int_t ic = 2; ic <= 142; ic++)
+ {
+ Double_t integral = 0;
+ for (Int_t ishiftR = 0; ishiftR < 2; ishiftR++)
+ {
+ for (Int_t ishiftC = -2; ishiftC < 2; ishiftC++)
+ {
+ if (ir + ishiftR >= 1 && ir + ishiftR <= 16 &&
+ ic + ishiftC >= 1 && ic + ishiftC <= 144)
+ {
+
+ for(Int_t tb = 0; tb< fTimeMax; tb++){
+ integral += phvalue[ir + ishiftR-1][ic + ishiftC-1][tb];
+ }// addtb
+ } //addsignal
+ } //shiftC
+ } // shiftR
+
+ if (integralMax < integral)
+ {
+ imaxRow = ir;
+ imaxCol = ic;
+ integralMax = integral;
+ } // check max integral
+ } //ic
+ } // ir
+
+ //printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
+
+ if((imaxRow == 0) || (imaxCol == 0)) {
+ used=1;
+ return used;
+ }
+ //CheckGoodTrackletV0(fDetectorPreviousTrack,imaxRow,imaxCol);
+ //if(!fGoodTracklet) used = 1;;
+
+ // /////////////////////////////////////////////////////
+ // sum ober 2 row and 4 pad cols for each time bins
+ // ////////////////////////////////////////////////////
+
+
+ for (Int_t ir = imaxRow - 1; ir < imaxRow + 1; ir++)
+ {
+ for (Int_t ic = imaxCol - 2; ic < imaxCol + 2; ic++)
+ {
+ for(Int_t it = 0; it < fTimeMax; it++){
+ sum[it] += phvalue[ir][ic][it];
+ }
+ }//ic
+ }//ir
+
+ Int_t nbcl = 0;
+ Double_t sumcharge = 0.0;
+ for(Int_t it = 0; it < fTimeMax; it++){
+ sumcharge += sum[it];
+ if(sum[it] > 20.0) nbcl++;
+ }
+
+
+ /////////////////////////////////////////////////////////
+ // Debug
+ ////////////////////////////////////////////////////////
+ if(fDebugLevel > 0){
+ if ( !fDebugStreamer ) {
+ //debug stream
TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibra.root");
+ fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- (* fDebugStreamer) << "VDRIFT0"<<
- "Npoints="<<Npoints<<
+ }
+
+ Double_t amph0 = sum[0];
+ Double_t amphlast = sum[fTimeMax-1];
+ Double_t rms = TMath::RMS(fTimeMax,sum);
+ Int_t goodtracklet = (Int_t) fGoodTracklet;
+ for(Int_t it = 0; it < fTimeMax; it++){
+ Double_t clustera = sum[it];
+
+ (* fDebugStreamer) << "FillDAQa"<<
+ "ampTotal="<<sumcharge<<
+ "row="<<imaxRow<<
+ "col="<<imaxCol<<
+ "detector="<<idect<<
+ "amph0="<<amph0<<
+ "amphlast="<<amphlast<<
+ "goodtracklet="<<goodtracklet<<
+ "clustera="<<clustera<<
+ "it="<<it<<
+ "rms="<<rms<<
"\n";
-
+ }
+ }
+
+ ////////////////////////////////////////////////////////
+ // fill
+ ///////////////////////////////////////////////////////
+ if(sum[0] > 100.0) used = 1;
+ if(nbcl < fNumberClusters) used = 1;
+ if(nbcl > fNumberClustersf) used = 1;
+
+ //if(fDetectorPreviousTrack == 15){
+ // printf("rms %f and first time bin %f\n",TMath::RMS(fTimeMax,sum),sum[0]);
+ //}
+ //if((TMath::RMS(fTimeMax,sum) <= 10.0) && (sum[0] > 200.0)) return 1;
+ if(used == 0){
+ for(Int_t it = 0; it < fTimeMax; it++){
+ if(fFillWithZero) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
+ else{
+ if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
+ }
+ }
- (* fDebugStreamer) << "VDRIFT"<<
- "snpright="<<snpright<<
- "Npoints="<<Npoints<<
- "nbli="<<nbli<<
- "detector="<<detector<<
- "snp="<<snp<<
- "tnp="<<tnp<<
- "tgl="<<tgl<<
- "tnt="<<tnt<<
- "y="<<y<<
- "z="<<z<<
- "dydt="<<dydt<<
- "dzdx="<<dzdx<<
- "crossrow="<<crossrow<<
- "errorpar="<<errorpar<<
- "pointError="<<pointError<<
- "\n";
+
+ //((TH2I *)GetCH2d()->Fill(sumcharge/30.0,fDetectorPreviousTrack));
+ used = 2;
+ //printf("Pass Detector %d\n",fDetectorPreviousTrack);
}
+
+ return used;
- if(Npoints < fNumberClusters) return kFALSE;
- if(snpright == 0) return kFALSE;
- if(pointError >= 0.1) return kFALSE;
- if(crossrow == 1) return kFALSE;
+}
+//____________Online trackling in AliTRDtrigger________________________________
+Bool_t AliTRDCalibraFillHisto::UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins)
+{
+ //
+ // For the DAQ
+ // Fill a simple average pulse height
+ //
+
+
+ ((TProfile2D *)GetPH2d(nbtimebins,fSf))->Fill((Float_t) timebin/fSf,det+0.5,(Float_t) signal);
+
+
+ return kTRUE;
+
+}
+//____________Write_____________________________________________________
+//_____________________________________________________________________
+void AliTRDCalibraFillHisto::Write2d(const Char_t *filename, Bool_t append)
+{
+ //
+ // Write infos to file
+ //
+
+ //For debugging
+ if ( fDebugStreamer ) {
+ delete fDebugStreamer;
+ fDebugStreamer = 0x0;
+ }
+
+ AliInfo(Form("Numbertrack: %d Numberusedch[0]: %d, Numberusedch[1]: %d Numberusedph[0]: %d, Numberusedph[1]: %d"
+ ,fNumberTrack
+ ,fNumberUsedCh[0]
+ ,fNumberUsedCh[1]
+ ,fNumberUsedPh[0]
+ ,fNumberUsedPh[1]));
+
+ TDirectory *backup = gDirectory;
+ TString option;
+
+ if ( append )
+ option = "update";
+ else
+ option = "recreate";
+
+ TFile f(filename,option.Data());
+ TStopwatch stopwatch;
+ stopwatch.Start();
+ if(fVector2d) {
+ f.WriteTObject(fCalibraVector);
+ }
+
+ if (fCH2dOn ) {
+ if (fHisto2d) {
+ f.WriteTObject(fCH2d);
+ }
+ }
+ if (fPH2dOn ) {
+ if (fHisto2d) {
+ f.WriteTObject(fPH2d);
+ }
+ }
+ if (fPRF2dOn) {
+ if (fHisto2d) {
+ f.WriteTObject(fPRF2d);
+ }
+ }
if(fLinearFitterOn){
- //Add to the linear fitter of the detector
- if( TMath::Abs(snp) < 1.){
- Double_t x = tnp-dzdx*tnt;
- (GetLinearFitter(detector,kTRUE))->AddPoint(&x,dydt);
- if(fLinearFitterDebugOn) {
- ((TH2F *) GetLinearFitterHisto(detector,kTRUE))->Fill(tnp,pars[1]);
+ if(fLinearFitterDebugOn) AnalyseLinearFitter();
+ f.WriteTObject(fLinearVdriftFit);
+ }
+
+ f.Close();
+
+ if ( backup ) backup->cd();
+
+ AliInfo(Form("Execution time Write2d: R:%.2fs C:%.2fs"
+ ,stopwatch.RealTime(),stopwatch.CpuTime()));
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Stats stuff
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//___________________________________________probe the histos__________________________________________________
+Double_t *AliTRDCalibraFillHisto::StatH(TH2 *h, Int_t i)
+{
+ //
+ // Check the number of stats in h, 0 is TH2I 1 is TProfile2D
+ // debug mode with 2 for TH2I and 3 for TProfile2D
+ // It gives a pointer to a Double_t[7] with the info following...
+ // [0] : number of calibration groups with entries
+ // [1] : minimal number of entries found
+ // [2] : calibration group number of the min
+ // [3] : maximal number of entries found
+ // [4] : calibration group number of the max
+ // [5] : mean number of entries found
+ // [6] : mean relative error
+ //
+
+ Double_t *info = new Double_t[7];
+
+ // Number of Xbins (detectors or groups of pads)
+ Int_t nbins = h->GetNbinsY(); //number of calibration groups
+ Int_t nxbins = h->GetNbinsX(); //number of bins per histo
+
+ // Initialise
+ Double_t nbwe = 0; //number of calibration groups with entries
+ Double_t minentries = 0; //minimal number of entries found
+ Double_t maxentries = 0; //maximal number of entries found
+ Double_t placemin = 0; //calibration group number of the min
+ Double_t placemax = -1; //calibration group number of the max
+ Double_t meanstats = 0.0; //mean number of entries over the calibration group with at least ome entry
+ Double_t meanrelativerror = 0.0; //mean relativ error in the TProfile2D
+
+ Double_t counter = 0;
+
+ //Debug
+ TH1F *nbEntries = 0x0;//distribution of the number of entries
+ TH1F *nbEntriesPerGroup = 0x0;//Number of entries per group
+ TProfile *nbEntriesPerSp = 0x0;//Number of entries for one supermodule
+
+ // Beginning of the loop over the calibration groups
+ for (Int_t idect = 0; idect < nbins; idect++) {
+
+ TH1I *projch = (TH1I *) h->ProjectionX("projch",idect+1,idect+1,(Option_t *)"e");
+ projch->SetDirectory(0);
+
+ // Number of entries for this calibration group
+ Double_t nentries = 0.0;
+ if((i%2) == 0){
+ for (Int_t k = 0; k < nxbins; k++) {
+ nentries += h->GetBinContent(h->GetBin(k+1,idect+1));
}
- fEntriesLinearFitter[detector]++;
}
+ else{
+ for (Int_t k = 0; k < nxbins; k++) {
+ nentries += ((TProfile2D *)h)->GetBinEntries(h->GetBin(k+1,idect+1));
+ if(h->GetBinContent(h->GetBin(k+1,idect+1)) != 0) {
+ meanrelativerror += (h->GetBinError(h->GetBin(k+1,idect+1))/(TMath::Abs(h->GetBinContent(h->GetBin(k+1,idect+1)))));
+ counter++;
+ }
+ }
+ }
+
+ //Debug
+ if(i > 1){
+ if((!((Bool_t)nbEntries)) && (nentries > 0)){
+ nbEntries = new TH1F("Number of entries","Number of entries"
+ ,100,(Int_t)nentries/2,nentries*2);
+ nbEntries->SetDirectory(0);
+ nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
+ ,nbins,0,nbins);
+ nbEntriesPerGroup->SetDirectory(0);
+ nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
+ ,(Int_t)(nbins/18),0,(Int_t)(nbins/18));
+ nbEntriesPerSp->SetDirectory(0);
+ }
+ if(nbEntries){
+ if(nentries > 0) nbEntries->Fill(nentries);
+ nbEntriesPerGroup->Fill(idect+0.5,nentries);
+ nbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
+ }
+ }
+
+ //min amd max
+ if(nentries > maxentries){
+ maxentries = nentries;
+ placemax = idect;
+ }
+ if(idect == 0) {
+ minentries = nentries;
+ }
+ if(nentries < minentries){
+ minentries = nentries;
+ placemin = idect;
+ }
+ //nbwe
+ if(nentries > 0) {
+ nbwe++;
+ meanstats += nentries;
+ }
+ }//calibration groups loop
+
+ if(nbwe > 0) meanstats /= nbwe;
+ if(counter > 0) meanrelativerror /= counter;
+
+ AliInfo(Form("There are %f calibration groups with entries",nbwe));
+ AliInfo(Form("The minimum number of entries is %f for the group %f",minentries,placemin));
+ AliInfo(Form("The maximum number of entries is %f for the group %f",maxentries,placemax));
+ AliInfo(Form("The mean number of entries is %f",meanstats));
+ if((i%2) == 1) AliInfo(Form("The mean relative error is %f",meanrelativerror));
+
+ info[0] = nbwe;
+ info[1] = minentries;
+ info[2] = placemin;
+ info[3] = maxentries;
+ info[4] = placemax;
+ info[5] = meanstats;
+ info[6] = meanrelativerror;
+
+ if(i > 1){
+ gStyle->SetPalette(1);
+ gStyle->SetOptStat(1111);
+ gStyle->SetPadBorderMode(0);
+ gStyle->SetCanvasColor(10);
+ gStyle->SetPadLeftMargin(0.13);
+ gStyle->SetPadRightMargin(0.01);
+ TCanvas *stat = new TCanvas("stat","",50,50,600,800);
+ stat->Divide(2,1);
+ stat->cd(1);
+ nbEntries->Draw("");
+ stat->cd(2);
+ nbEntriesPerSp->SetStats(0);
+ nbEntriesPerSp->Draw("");
+ TCanvas *stat1 = new TCanvas("stat1","",50,50,600,800);
+ stat1->cd();
+ nbEntriesPerGroup->SetStats(0);
+ nbEntriesPerGroup->Draw("");
}
- //AliInfo("End of FindP1TrackPH with success!")
- return kTRUE;
+
+ return info;
+
+}
+//____________________________________________________________________________
+Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberCH()
+{
+ //
+ // Return a Int_t[4] with:
+ // 0 Mean number of entries
+ // 1 median of number of entries
+ // 2 rms of number of entries
+ // 3 number of group with entries
+ //
+
+ Double_t *stat = new Double_t[4];
+ stat[3] = 0.0;
+
+ Int_t nbofgroups = CalculateTotalNumberOfBins(0);
+ Double_t *weight = new Double_t[nbofgroups];
+ Int_t *nonul = new Int_t[nbofgroups];
+
+ for(Int_t k = 0; k < nbofgroups; k++){
+ if(fEntriesCH[k] > 0) {
+ weight[k] = 1.0;
+ nonul[(Int_t)stat[3]] = fEntriesCH[k];
+ stat[3]++;
+ }
+ else weight[k] = 0.0;
+ }
+ stat[0] = TMath::Mean(nbofgroups,fEntriesCH,weight);
+ stat[1] = TMath::Median(nbofgroups,fEntriesCH,weight);
+ stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+
+ return stat;
+
+}
+//____________________________________________________________________________
+Double_t *AliTRDCalibraFillHisto::GetMeanMedianRMSNumberLinearFitter() const
+{
+ //
+ // Return a Int_t[4] with:
+ // 0 Mean number of entries
+ // 1 median of number of entries
+ // 2 rms of number of entries
+ // 3 number of group with entries
+ //
+
+ Double_t *stat = new Double_t[4];
+ stat[3] = 0.0;
+
+ Int_t nbofgroups = 540;
+ Double_t *weight = new Double_t[nbofgroups];
+ Int_t *nonul = new Int_t[nbofgroups];
+
+ for(Int_t k = 0; k < nbofgroups; k++){
+ if(fEntriesLinearFitter[k] > 0) {
+ weight[k] = 1.0;
+ nonul[(Int_t) stat[3]] = fEntriesLinearFitter[k];
+ stat[3]++;
+ }
+ else weight[k] = 0.0;
+ }
+ stat[0] = TMath::Mean(nbofgroups,fEntriesLinearFitter,weight);
+ stat[1] = TMath::Median(nbofgroups,fEntriesLinearFitter,weight);
+ stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+
+ return stat;
+
+}
+//////////////////////////////////////////////////////////////////////////////////////
+// Create Histos
+//////////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::CreatePRF2d(Int_t nn)
+{
+ //
+ // Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
+ // If fNgroupprf is zero then no binning in tnp
+ //
+
+ TString name("Nz");
+ name += fCalibraMode->GetNz(2);
+ name += "Nrphi";
+ name += fCalibraMode->GetNrphi(2);
+ name += "Ngp";
+ name += fNgroupprf;
+
+ if(fNgroupprf != 0){
+
+ fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
+ ,2*fNgroupprf*fNumberBinPRF,-3.0*fNgroupprf,3.0*fNgroupprf,nn,0,nn);
+ fPRF2d->SetYTitle("Det/pad groups");
+ fPRF2d->SetXTitle("Position x/W [pad width units]");
+ fPRF2d->SetZTitle("Q_{i}/Q_{total}");
+ fPRF2d->SetStats(0);
+ }
+ else{
+ fPRF2d = new TProfile2D("PRF2d",(const Char_t *) name
+ ,fNumberBinPRF,-1.5,1.5,nn,0,nn);
+ fPRF2d->SetYTitle("Det/pad groups");
+ fPRF2d->SetXTitle("Position x/W [pad width units]");
+ fPRF2d->SetZTitle("Q_{i}/Q_{total}");
+ fPRF2d->SetStats(0);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::CreatePH2d(Int_t nn)
+{
+ //
+ // Create the 2D histos
+ //
+
+ TString name("Nz");
+ name += fCalibraMode->GetNz(1);
+ name += "Nrphi";
+ name += fCalibraMode->GetNrphi(1);
+
+ fPH2d = new TProfile2D("PH2d",(const Char_t *) name
+ ,fTimeMax,-0.5/fSf,(Float_t) (fTimeMax-0.5)/fSf
+ ,nn,0,nn);
+ fPH2d->SetYTitle("Det/pad groups");
+ fPH2d->SetXTitle("time [#mus]");
+ fPH2d->SetZTitle("<PH> [a.u.]");
+ fPH2d->SetStats(0);
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::CreateCH2d(Int_t nn)
+{
+ //
+ // Create the 2D histos
+ //
+
+ TString name("Nz");
+ name += fCalibraMode->GetNz(0);
+ name += "Nrphi";
+ name += fCalibraMode->GetNrphi(0);
+
+ fCH2d = new TH2I("CH2d",(const Char_t *) name
+ ,fNumberBinCharge,0,300,nn,0,nn);
+ fCH2d->SetYTitle("Det/pad groups");
+ fCH2d->SetXTitle("charge deposit [a.u]");
+ fCH2d->SetZTitle("counts");
+ fCH2d->SetStats(0);
+ fCH2d->Sumw2();
}
-//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::HandlePRF()
+//////////////////////////////////////////////////////////////////////////////////
+// Set relative scale
+/////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetRelativeScale(Float_t RelativeScale)
{
//
- // For the offline tracking
- // Fit the tracklet with a line and take the position as reference for the PRF
+ // Set the factor that will divide the deposited charge
+ // to fit in the histo range [0,300]
//
-
- //Number of points
- Int_t Npoints = fListClusters->GetEntriesFast(); // number of total points
- Int_t Nb3pc = 0; // number of three pads clusters used for fit
- Int_t detector = ((AliTRDcluster *) fListClusters->At(0))->GetDetector(); // detector
-
- // To see the difference due to the fit
- Double_t *padPositions;
- padPositions = new Double_t[Npoints];
- for(Int_t k = 0; k < Npoints; k++){
- padPositions[k] = 0.0;
+ if (RelativeScale > 0.0) {
+ fRelativeScale = RelativeScale;
}
+ else {
+ AliInfo("RelativeScale must be strict positif!");
+ }
-
- //Find the position by a fit
- TLinearFitter fitter(2,"pol1");
- fitter.StoreData(kFALSE);
- fitter.ClearPoints();
- for(Int_t k = 0; k < Npoints; k++){
- //Take the cluster
- AliTRDcluster *cl = (AliTRDcluster *) fListClusters->At(k);
- Short_t *signals = cl->GetSignals();
- Double_t time = cl->GetLocalTimeBin();
- //Calculate x if possible
- Float_t xcenter = 0.0;
- Bool_t echec = kTRUE;
- if((time<=7) || (time>=21)) continue;
- // Center 3 balanced: position with the center of the pad
- if ((((Float_t) signals[3]) > 0.0) &&
- (((Float_t) signals[2]) > 0.0) &&
- (((Float_t) signals[4]) > 0.0)) {
- echec = kFALSE;
- // Security if the denomiateur is 0
- if ((((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3]))) /
- ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))) != 1.0) {
- xcenter = 0.5 * (TMath::Log((Float_t) (((Float_t) signals[4]) / ((Float_t) signals[2]))))
- / (TMath::Log(((Float_t) (((Float_t) signals[3]) * ((Float_t) signals[3])))
- / ((Float_t) (((Float_t) signals[2]) * ((Float_t) signals[4])))));
- }
- else {
- echec = kTRUE;
- }
- }
- if(TMath::Abs(xcenter) > 0.5) echec = kTRUE;
- if(echec) continue;
- //if no echec: calculate with the position of the pad
- // Position of the cluster
- Double_t padPosition = xcenter + cl->GetPad();
- padPositions[k] = padPosition;
- Nb3pc++;
- fitter.AddPoint(&time, padPosition,1);
- }//clusters loop
-
- //printf("Nb3pc %d, Npoints %d\n",Nb3pc,Npoints);
- if(Nb3pc < 3) return kFALSE;
- fitter.Eval();
- TVectorD line(2);
- fitter.GetParameters(line);
- Float_t pointError = -1.0;
- pointError = TMath::Sqrt(fitter.GetChisquare()/Nb3pc);
+}
+//////////////////////////////////////////////////////////////////////////////////
+// Quick way to fill a histo
+//////////////////////////////////////////////////////////////////////////////////
+//_____________________________________________________________________
+void AliTRDCalibraFillHisto::FillCH2d(Int_t x, Float_t y)
+{
+ //
+ // FillCH2d: Marian style
+ //
-
- // Now fill the PRF
- for(Int_t k = 0; k < Npoints; k++){
- //Take the cluster
- AliTRDcluster *cl = (AliTRDcluster *) fListClusters->At(k);
- Short_t *signals = cl->GetSignals(); // signal
- Double_t time = cl->GetLocalTimeBin(); // time bin
- Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
- Float_t padPos = cl->GetPad(); // middle pad
- Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
- Float_t ycenter = 0.0; // relative center charge
- Float_t ymin = 0.0; // relative left charge
- Float_t ymax = 0.0; // relative right charge
- Double_t tgl = fPar3[(Int_t)time]; // dz/dl and not dz/dx
- Double_t pt = fPar4[(Int_t)time]; // pt
- Float_t dzdx = 0.0; // dzdx
-
-
- //Requiere simply two pads clusters at least
- if(((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[2]) > 0.0)) ||
- ((((Float_t) signals[3]) > 0.0) && (((Float_t) signals[4]) > 0.0))){
- Float_t sum = ((Float_t) signals[2]) + ((Float_t) signals[3]) + ((Float_t) signals[4]);
- if(sum > 0.0) ycenter = ((Float_t) signals[3])/ sum;
- if(sum > 0.0) ymin = ((Float_t) signals[2])/ sum;
- if(sum > 0.0) ymax = ((Float_t) signals[4])/ sum;
- }
-
- //calibration group
- Int_t *rowcol = CalculateRowCol(cl); // calcul col and row pad of the cluster
- Int_t grouplocal = CalculateCalibrationGroup(2,rowcol); // calcul the corresponding group
- Int_t caligroup = fCalibraMode->GetXbins(2)+ grouplocal; // calcul the corresponidng group
- Double_t snp = fPar2[(Int_t)time]; // sin angle in xy plan
- 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
- Double_t xdiff = dpad; // reconstructed position constant
- Double_t x = dpad; // reconstructed position moved
- Float_t Ep = pointError; // error of fit
- Float_t signal1 = (Float_t)signals[1]; // signal at the border
- Float_t signal3 = (Float_t)signals[3]; // signal
- Float_t signal2 = (Float_t)signals[2]; // signal
- Float_t signal4 = (Float_t)signals[4]; // signal
- Float_t signal5 = (Float_t)signals[5]; // signal at the border
- Float_t tnp = 0.0;
- if(TMath::Abs(snp) < 1.0){
- tnp = snp / (TMath::Sqrt(1-snp*snp));
- dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
- }
-
-
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
- TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibra.root");
- if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- (* fDebugStreamer) << "PRF0"<<
- "caligroup="<<caligroup<<
- "detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
- "Npoints="<<Npoints<<
- "Np="<<Nb3pc<<
- "Ep="<<Ep<<
- "snp="<<snp<<
- "tnp="<<tnp<<
- "tgl="<<tgl<<
- "dzdx="<<dzdx<<
- "pt="<<pt<<
- "padPos="<<padPos<<
- "padPosition="<<padPositions[k]<<
- "padPosTracklet="<<padPosTracklet<<
- "x="<<x<<
- "ycenter="<<ycenter<<
- "ymin="<<ymin<<
- "ymax="<<ymax<<
- "xcl="<<xcl<<
- "qcl="<<qcl<<
- "signal1="<<signal1<<
- "signal2="<<signal2<<
- "signal3="<<signal3<<
- "signal4="<<signal4<<
- "signal5="<<signal5<<
- "time="<<time<<
- "\n";
- x = xdiff;
- Int_t type=0;
- Float_t y = ycenter;
- (* fDebugStreamer) << "PRFALL"<<
- "caligroup="<<caligroup<<
- "detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
- "Npoints="<<Npoints<<
- "Np="<<Nb3pc<<
- "Ep="<<Ep<<
- "type="<<type<<
- "snp="<<snp<<
- "tnp="<<tnp<<
- "tgl="<<tgl<<
- "dzdx="<<dzdx<<
- "pt="<<pt<<
- "padPos="<<padPos<<
- "padPosition="<<padPositions[k]<<
- "padPosTracklet="<<padPosTracklet<<
- "x="<<x<<
- "y="<<y<<
- "xcl="<<xcl<<
- "qcl="<<qcl<<
- "signal1="<<signal1<<
- "signal2="<<signal2<<
- "signal3="<<signal3<<
- "signal4="<<signal4<<
- "signal5="<<signal5<<
- "time="<<time<<
- "\n";
- x=-(xdiff+1);
- y = ymin;
- type=-1;
- (* fDebugStreamer) << "PRFALL"<<
- "caligroup="<<caligroup<<
- "detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
- "Npoints="<<Npoints<<
- "Np="<<Nb3pc<<
- "Ep="<<Ep<<
- "type="<<type<<
- "snp="<<snp<<
- "tnp="<<tnp<<
- "tgl="<<tgl<<
- "dzdx="<<dzdx<<
- "pt="<<pt<<
- "padPos="<<padPos<<
- "padPosition="<<padPositions[k]<<
- "padPosTracklet="<<padPosTracklet<<
- "x="<<x<<
- "y="<<y<<
- "xcl="<<xcl<<
- "qcl="<<qcl<<
- "signal1="<<signal1<<
- "signal2="<<signal2<<
- "signal3="<<signal3<<
- "signal4="<<signal4<<
- "signal5="<<signal5<<
- "time="<<time<<
- "\n";
- x=1-xdiff;
- y = ymax;
- type=1;
-
- (* fDebugStreamer) << "PRFALL"<<
- "caligroup="<<caligroup<<
- "detector="<<detector<<
- "plane="<<plane<<
- "chamber="<<chamber<<
- "Npoints="<<Npoints<<
- "Np="<<Nb3pc<<
- "Ep="<<Ep<<
- "type="<<type<<
- "snp="<<snp<<
- "tnp="<<tnp<<
- "tgl="<<tgl<<
- "dzdx="<<dzdx<<
- "pt="<<pt<<
- "padPos="<<padPos<<
- "padPosition="<<padPositions[k]<<
- "padPosTracklet="<<padPosTracklet<<
- "x="<<x<<
- "y="<<y<<
- "xcl="<<xcl<<
- "qcl="<<qcl<<
- "signal1="<<signal1<<
- "signal2="<<signal2<<
- "signal3="<<signal3<<
- "signal4="<<signal4<<
- "signal5="<<signal5<<
- "time="<<time<<
- "\n";
-
- }
-
- // some cuts
- if(Npoints < fNumberClusters) continue;
- if(Nb3pc <= 5) continue;
- if((time >= 21) || (time < 7)) continue;
- if(TMath::Abs(snp) >= 1.0) continue;
- if(qcl < 80) continue;
-
- Bool_t echec = kFALSE;
- Double_t shift = 0.0;
- //Calculate the shift in x coresponding to this tnp
- if(fNgroupprf != 0.0){
- shift = -3.0*(fNgroupprf-1)-1.5;
- Double_t limithigh = -0.2*(fNgroupprf-1);
- if((tnp < (-0.2*fNgroupprf)) || (tnp > (0.2*fNgroupprf))) echec = kTRUE;
- else{
- while(tnp > limithigh){
- limithigh += 0.2;
- shift += 3.0;
- }
- }
- }
- if (fHisto2d && !echec) {
- fPRF2d->Fill(shift+dpad,(caligroup+0.5),ycenter);
- if(ymin > 0.0) {
- fPRF2d->Fill(shift-(dpad+1.0),(caligroup+0.5),ymin);
- fPRF2d->Fill(shift+(dpad+1.0),(caligroup+0.5),ymin);
- }
- if(ymax > 0.0) {
- fPRF2d->Fill(shift+1.0-dpad,(caligroup+0.5),ymax);
- fPRF2d->Fill(shift-1.0+dpad,(caligroup+0.5),ymax);
- }
- }
- //Not equivalent anymore here!
- if (fVector2d && !echec) {
- fCalibraVector->UpdateVectorPRF(caligroup,shift+dpad,ycenter);
- if(ymin > 0.0) {
- fCalibraVector->UpdateVectorPRF(caligroup,shift-(dpad+1.0),ymin);
- fCalibraVector->UpdateVectorPRF(caligroup,shift+(dpad+1.0),ymin);
- }
- if(ymax > 0.0) {
- fCalibraVector->UpdateVectorPRF(caligroup,shift+1.0-dpad,ymax);
- fCalibraVector->UpdateVectorPRF(caligroup,shift-1.0+dpad,ymax);
- }
- }
- }
- return kTRUE;
+ //skip simply the value out of range
+ if((y>=300.0) || (y<0.0)) return;
+ //Calcul the y place
+ Int_t yplace = (Int_t) (fNumberBinCharge*y/300.0)+1;
+ Int_t place = (fNumberBinCharge+2)*(x+1)+yplace;
+
+ //Fill
+ fCH2d->GetArray()[place]++;
+
}
-//
-//____________Some basic geometry function_____________________________________
-//
+
+//////////////////////////////////////////////////////////////////////////////////
+// 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);
}
return ((Int_t) (d / fg));
}
+///////////////////////////////////////////////////////////////////////////////////
+// Getter functions for DAQ of the CH2d and the PH2d
+//////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
-TProfile2D* AliTRDCalibraFillHisto::GetPH2d(Int_t nbtimebin, Float_t samplefrequency, Bool_t force)
+TProfile2D* AliTRDCalibraFillHisto::GetPH2d(Int_t nbtimebin, Float_t samplefrequency)
{
//
// return pointer to fPH2d TProfile2D
- // if force is true create a new TProfile2D if it doesn't exist allready
+ // create a new TProfile2D if it doesn't exist allready
//
- if ( !force || fPH2d )
+ if ( fPH2d )
return fPH2d;
// Some parameters
fTimeMax = nbtimebin;
fSf = samplefrequency;
- /*
- AliInfo(Form("The pad calibration mode for the drift velocity calibration: Nz %d, and Nrphi %d"
- ,fCalibraMode->GetNz(1)
- ,fCalibraMode->GetNrphi(1)));
-
- // Calcul the number of Xbins
- Int_t Ntotal1 = 0;
- fCalibraMode->ModePadCalibration(2,1);
- fCalibraMode->ModePadFragmentation(0,2,0,1);
- fCalibraMode->SetDetChamb2(1);
- Ntotal1 += 6 * 18 * fCalibraMode->GetDetChamb2(1);
- fCalibraMode->ModePadCalibration(0,1);
- fCalibraMode->ModePadFragmentation(0,0,0,1);
- fCalibraMode->SetDetChamb0(1);
- Ntotal1 += 6 * 4 * 18 * fCalibraMode->GetDetChamb0(1);
- AliInfo(Form("Total number of Xbins: %d",Ntotal1));
-
- CreatePH2d(Ntotal1);
- */
-
CreatePH2d(540);
return fPH2d;
}
//_____________________________________________________________________
-TLinearFitter* AliTRDCalibraFillHisto::GetLinearFitter(Int_t detector, Bool_t force)
+TH2I* AliTRDCalibraFillHisto::GetCH2d()
{
//
- // return pointer to TLinearFitter Calibration
- // if force is true create a new TLinearFitter if it doesn't exist allready
+ // return pointer to fCH2d TH2I
+ // create a new TH2I if it doesn't exist allready
//
- if ( !force || fLinearFitterArray.UncheckedAt(detector) )
- return (TLinearFitter*)fLinearFitterArray.UncheckedAt(detector);
+ if ( fCH2d )
+ return fCH2d;
- // if we are forced and TLinearFitter doesn't yet exist create it
+ CreateCH2d(540);
- // new TLinearFitter
- TLinearFitter *linearfitter = new TLinearFitter(2,"pol1");
- fLinearFitterArray.AddAt(linearfitter,detector);
- return linearfitter;
+ return fCH2d;
}
+////////////////////////////////////////////////////////////////////////////////////////////
+// Drift velocity calibration
+///////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
-TH2F* AliTRDCalibraFillHisto::GetLinearFitterHisto(Int_t detector, Bool_t force)
+TLinearFitter* AliTRDCalibraFillHisto::GetLinearFitter(Int_t detector, Bool_t force)
{
//
- // return pointer to TH2F histo
- // if force is true create a new histo if it doesn't exist allready
+ // return pointer to TLinearFitter Calibration
+ // if force is true create a new TLinearFitter if it doesn't exist allready
//
- if ( !force || fLinearFitterHistoArray.UncheckedAt(detector) )
- return (TH2F*)fLinearFitterHistoArray.UncheckedAt(detector);
- // if we are forced and TLinearFitter doesn't yes exist create it
+ if ((!force) || (fLinearFitterArray.UncheckedAt(detector))){
+ return (TLinearFitter*)fLinearFitterArray.UncheckedAt(detector);
+ }
+
+ // if we are forced and TLinearFitter doesn't yet exist create it
- // new TH2F
- TString name("LFDV");
- name += detector;
-
- TH2F *lfdv = new TH2F((const Char_t *)name,(const Char_t *) name
- ,100,-1.0,1.0,100
- ,-2.0,2.0);
- lfdv->SetXTitle("tan(phi_{track})");
- lfdv->SetYTitle("dy/dt");
- lfdv->SetZTitle("Number of clusters");
- lfdv->SetStats(0);
- lfdv->SetDirectory(0);
-
- fLinearFitterHistoArray.AddAt(lfdv,detector);
- return lfdv;
+ // new TLinearFitter
+ TLinearFitter *linearfitter = new TLinearFitter(2,"pol1");
+ fLinearFitterArray.AddAt(linearfitter,detector);
+ return linearfitter;
}
-//_____________________________________________________________________
-void AliTRDCalibraFillHisto::FillCH2d(Int_t x, Float_t y)
+
+//____________________________________________________________________________
+void AliTRDCalibraFillHisto::AnalyseLinearFitter()
{
//
- // FillCH2d: Marian style
- //
-
- //skip simply the value out of range
- if((y>=300.0) || (y<0.0)) return;
-
- //Calcul the y place
- Int_t yplace = (Int_t) (fNumberBinCharge*y/300.0)+1;
- Int_t place = (fNumberBinCharge+2)*(x+1)+yplace;
-
- //Fill
- fCH2d->GetArray()[place]++;
-
+ // Analyse array of linear fitter because can not be written
+ // Store two arrays: one with the param the other one with the error param + number of entries
+ //
+
+ for(Int_t k = 0; k < 540; k++){
+ TLinearFitter *linearfitter = GetLinearFitter(k);
+ if((linearfitter!=0) && (fEntriesLinearFitter[k]>10)){
+ TVectorD *par = new TVectorD(2);
+ TVectorD pare = TVectorD(2);
+ TVectorD *parE = new TVectorD(3);
+ linearfitter->Eval();
+ linearfitter->GetParameters(*par);
+ linearfitter->GetErrors(pare);
+ Float_t ppointError = TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
+ (*parE)[0] = pare[0]*ppointError;
+ (*parE)[1] = pare[1]*ppointError;
+ (*parE)[2] = (Double_t) fEntriesLinearFitter[k];
+ ((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
+ ((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
+ }
+ }
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff