X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDCalibTask.cxx;h=39cf64f7b75be94773e2cbd7999e9979253d780f;hb=230a6a131f4168a240b49707bb2636046d5f8bbc;hp=aadec5e5c67ee415a11da6aada773a2c6af3d259;hpb=a987273c99d4a155cdc733a9ab7446ed695a9333;p=u%2Fmrichter%2FAliRoot.git diff --git a/TRD/AliTRDCalibTask.cxx b/TRD/AliTRDCalibTask.cxx index aadec5e5c67..39cf64f7b75 100644 --- a/TRD/AliTRDCalibTask.cxx +++ b/TRD/AliTRDCalibTask.cxx @@ -35,6 +35,7 @@ using namespace std; #include "TH2I.h" #include "TH1F.h" #include "TH2F.h" +#include "TH2S.h" #include "TList.h" #include "TMath.h" #include "TObject.h" @@ -45,13 +46,17 @@ using namespace std; #include "TStyle.h" #include "TLine.h" #include "TIterator.h" +#include "TLinearFitter.h" +#include "TVectorD.h" #include "AliAnalysisTask.h" #include "AliAnalysisManager.h" +#include "AliExternalTrackParam.h" #include "AliESDVertex.h" #include "AliESDEvent.h" #include "AliESDfriend.h" +#include "AliCentrality.h" #include "AliESDInputHandler.h" #include "AliESDtrack.h" #include "AliESDfriendTrack.h" @@ -66,11 +71,16 @@ using namespace std; #include "AliTRDCalibraVector.h" #include "AliTRDCalibraFillHisto.h" #include "AliTRDCalibraVdriftLinearFit.h" +#include "AliTRDCalibraExbAltFit.h" #include "AliTRDcalibDB.h" #include "AliCDBId.h" #include "AliLog.h" +#include "AliTRDCalibChamberStatus.h" +#include "AliTRDdEdxBaseUtils.h" +#include "AliTRDdEdxCalibHistArray.h" +#include "AliTRDdEdxCalibUtils.h" #include "AliTRDCalibTask.h" @@ -78,66 +88,94 @@ using namespace std; ClassImp(AliTRDCalibTask) //________________________________________________________________________ - AliTRDCalibTask::AliTRDCalibTask(const char *name) - : AliAnalysisTaskSE(name), fESD(0), - fESDfriend(0), - fkEsdTrack(0), - fFriendTrack(0), - fCalibObject(0), - fTrdTrack(0), - fCl(0), - fListHist(0), - fTRDCalibraFillHisto(0), - fNEvents(0), - fNbTRDTrack(0), - fNbTRDTrackOffline(0), - fNbTRDTrackStandalone(0), - fNbTPCTRDtrack(0), - fNbTimeBin(0), - fNbTimeBinOffline(0), - fNbTimeBinStandalone(0), - fNbClusters(0), - fNbClustersOffline(0), - fNbClustersStandalone(0), - fNbTracklets(0), - fNbTrackletsOffline(0), - fNbTrackletsStandalone(0), - fAbsoluteGain(0), - fCH2dSum(0), - fPH2dSum(0), - fCH2dSM(0), - fPH2dSM(0), - fHisto2d(kTRUE), - fVector2d(kFALSE), - fVdriftLinear(kTRUE), - fNbTimeBins(0), - fSelectedTrigger(new TObjArray()), - fRejected(kTRUE), - fEsdTrackCuts(0), - fRequirePrimaryVertex(kFALSE), - fVtxTPC(kFALSE), - fVtxSPD(kFALSE), - fMinNbContributors(0), - fRangePrimaryVertexZ(9999999.0), - fLow(0), - fHigh(30), - fFillZero(kFALSE), - fNormalizeNbOfCluster(kFALSE), - fRelativeScale(0.0), - fMaxCluster(100.0), - fNbMaxCluster(2), - fOfflineTracks(kFALSE), - fStandaloneTracks(kFALSE), - fVersionGainUsed(-1), - fSubVersionGainUsed(-1), - fVersionGainLocalUsed(-1), - fSubVersionGainLocalUsed(-1), - fVersionVdriftUsed(-1), - fSubVersionVdriftUsed(-1), - fCalDetGain(0x0), - fMaxEvent(0), - fCounter(0), - fDebug(0) +AliTRDCalibTask::AliTRDCalibTask(const char *name) +: AliAnalysisTaskSE(name), fESD(0), + fkEsdTrack(0), + fFriendTrack(0), + fCalibObject(0), + fTrdTrack(0), + fCl(0), + fListHist(0), + fTRDCalibraFillHisto(0), + fTRDChamberStatus(0), + fNEvents(0), + fNEventsInput(0), + fNbTRDTrack(0), + fNbTRDTrackOffline(0), + fNbTRDTrackStandalone(0), + fNbTPCTRDtrack(0), + fNbGoodTracks(0), + fNbTimeBin(0), + fNbTimeBinOffline(0), + fNbTimeBinStandalone(0), + fNbClusters(0), + fNbClustersOffline(0), + fNbClustersStandalone(0), + fNbTracklets(0), + fNbTrackletsOffline(0), + fNbTrackletsStandalone(0), + fAbsoluteGain(0), + fCH2dSum(0), + fPH2dSum(0), + fCH2dSM(0), + fPH2dSM(0), + fCH2dTest(0), + fPH2dTest(0), + fLinearVdriftTest(0), + fOnInstance(kTRUE), + fHisto2d(kTRUE), + fVector2d(kFALSE), + fVdriftLinear(kTRUE), + fExbAlt(kFALSE), + fDebugLevelTRDCalibraFillHisto(0), + fNbTimeBins(0), + fNumberBinCharge(100), + fRangeCharge(150), + fVdBindx(32), + fVdBindy(70), + fVdRangex(0.8), + fVdRangey(1.4), + fSelectTrigger(kTRUE), + fSelectedTrigger(new TObjArray()), + fRejected(kTRUE), + fEsdTrackCuts(0), + fRequirePrimaryVertex(kFALSE), + fVtxTPC(kFALSE), + fVtxSPD(kFALSE), + fMinNbContributors(0), + fRangePrimaryVertexZ(9999999.0), + fRejectPileUpWithSPD(kFALSE), + fMinNbTracks(9), + fMaxNbTracks(999999999), + fCutWithVdriftCalib(kFALSE), + fMinNbTRDtracklets(0), + fMinTRDMomentum(0), + fScaleGainWithTPCSignal(kFALSE), + fLow(0), + fHigh(30), + fFillZero(kFALSE), + fNormalizeNbOfCluster(kFALSE), + fRelativeScale(0.0), + fMaxCluster(100.0), + fNbMaxCluster(2), + fOfflineTracks(kFALSE), + fStandaloneTracks(kFALSE), + fFirstRunGain(-1), + fVersionGainUsed(-1), + fSubVersionGainUsed(-1), + fFirstRunGainLocal(-1), + fVersionGainLocalUsed(-1), + fSubVersionGainLocalUsed(-1), + fFirstRunVdrift(-1), + fVersionVdriftUsed(-1), + fSubVersionVdriftUsed(-1), + fFirstRunExB(-1), + fVersionExBUsed(-1), + fSubVersionExBUsed(-1), + fCalDetGain(0x0), + fMaxEvent(0), + fCounter(0), + fPHQon(kTRUE) { // // Default constructor @@ -151,6 +189,7 @@ ClassImp(AliTRDCalibTask) fNrphi[1] = 0; fNrphi[2] = 0; + // Define input and output slots here // Input slot #0 works with a TChain DefineInput(0, TChain::Class()); @@ -169,10 +208,12 @@ AliTRDCalibTask::~AliTRDCalibTask() // Pointeur if(fNEvents) delete fNEvents; + if(fNEventsInput) delete fNEventsInput; if(fNbTRDTrack) delete fNbTRDTrack; if(fNbTRDTrackOffline) delete fNbTRDTrackOffline; if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone; if(fNbTPCTRDtrack) delete fNbTPCTRDtrack; + if(fNbGoodTracks) delete fNbGoodTracks; if(fNbTimeBin) delete fNbTimeBin; if(fNbTimeBinOffline) delete fNbTimeBinOffline; if(fNbTimeBinStandalone) delete fNbTimeBinStandalone; @@ -187,6 +228,13 @@ AliTRDCalibTask::~AliTRDCalibTask() if(fPH2dSum) delete fPH2dSum; if(fCH2dSM) delete fCH2dSM; if(fPH2dSM) delete fPH2dSM; + if(fCH2dTest) delete fCH2dTest; + if(fPH2dTest) delete fPH2dTest; + if(fLinearVdriftTest) delete fLinearVdriftTest; + if(IsPHQon()){ + AliTRDdEdxCalibUtils::DeleteHistArray(); + } + if(fCalDetGain) delete fCalDetGain; if(fSelectedTrigger) { @@ -197,41 +245,9 @@ AliTRDCalibTask::~AliTRDCalibTask() delete fEsdTrackCuts; } -} - -/* -//________________________________________________________________________ -void AliTRDCalibTask::ConnectInputData(Option_t *) -{ - // Connect ESD or AOD here - // Called once per event - - cout << "AliTRDCalibTask::ConnectInputData() IN" << endl; - - - // TTree* tree = dynamic_cast (GetInputData(0)); //pointer wird "umgecastet" auf anderen Variablentyp - // if (!tree) { - //Printf("ERROR: Could not read chain from input slot 0"); - // } else { - - AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if(fTRDChamberStatus) delete fTRDChamberStatus; - if (!esdH) { - //Printf("ERROR: Could not get ESDInputHandler"); - } else { - fESD = esdH->GetEvent(); - // esdH->SetActiveBranches("ESDfriend*"); - if ((esdH->GetTree())->GetBranch("ESDfriend.")) fESDfriend = esdH->GetESDfriend(); - //else printf("No friend ESD\n"); - //Printf("*** CONNECTED NEW EVENT ****"); - } - - - // } - //cout << "AliTRDCalibTask::ConnectInputData() OUT" << endl; - } -*/ //________________________________________________________________________ void AliTRDCalibTask::UserCreateOutputObjects() @@ -251,57 +267,85 @@ void AliTRDCalibTask::UserCreateOutputObjects() } } + // output list + fListHist = new TList(); + fListHist->SetOwner(); + + // init chamber status + fTRDChamberStatus = new AliTRDCalibChamberStatus(); + fTRDChamberStatus->Init(); + fListHist->Add(fTRDChamberStatus->GetSparseI()); + // instance calibration fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance(); - fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms - fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors - fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain - fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity - fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF - fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT - fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift - for(Int_t k = 0; k < 3; k++){ - if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) { - fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration - fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration - } - else { - if((fNz[k] == 100) && (fNrphi[k] == 100)) { - if(fVector2d) AliInfo("The mode all together is not supported by the vector method"); - fTRDCalibraFillHisto->SetAllTogether(k); + if(fOnInstance) { + fTRDCalibraFillHisto->SetNumberBinCharge(fNumberBinCharge); // set number of bin of the charge distribution + fTRDCalibraFillHisto->SetCutWithVdriftCalib(fCutWithVdriftCalib); // cut vdrift + fTRDCalibraFillHisto->SetMinNbTRDtracklets(fMinNbTRDtracklets); // min number of TRD tracklets + fTRDCalibraFillHisto->SetMinTRDMomentum(fMinTRDMomentum); // min TRD momentum + fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms + fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors + fTRDCalibraFillHisto->SetCH2dOn(); // choose to calibrate the gain + fTRDCalibraFillHisto->SetPH2dOn(); // choose to calibrate the drift velocity + fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF + fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT + fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift + fTRDCalibraFillHisto->SetExbAltFitOn(fExbAlt); // Alternative method for exb + fTRDCalibraFillHisto->SetScaleWithTPCSignal(fScaleGainWithTPCSignal); // Scale Gain with TPC signal + for(Int_t k = 0; k < 3; k++){ + if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) { + fTRDCalibraFillHisto->SetNz(k,fNz[k]); // Mode calibration + fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]); // Mode calibration } - if((fNz[k] == 10) && (fNrphi[k] == 10)) { - if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method"); - fTRDCalibraFillHisto->SetPerSuperModule(k); + else { + if((fNz[k] == 100) && (fNrphi[k] == 100)) { + if(fVector2d) AliInfo("The mode all together is not supported by the vector method"); + fTRDCalibraFillHisto->SetAllTogether(k); + } + if((fNz[k] == 10) && (fNrphi[k] == 10)) { + if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method"); + fTRDCalibraFillHisto->SetPerSuperModule(k); + } } } - } - // Variables for how to fill - fTRDCalibraFillHisto->SetFillWithZero(fFillZero); - fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster); - fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster); - fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster); + // Variables for how to fill + fTRDCalibraFillHisto->SetFillWithZero(fFillZero); + fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster); + fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster); + fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster); - // Init with 30 timebins - fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos - fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters - fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters + // Init with 30 timebins + fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos + fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters + fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters + + // For testing only + fTRDCalibraFillHisto->SetDebugLevel(fDebugLevelTRDCalibraFillHisto); //debug stuff + + if(fHisto2d) { + fListHist->Add(fTRDCalibraFillHisto->GetCH2d()); + fListHist->Add(fTRDCalibraFillHisto->GetPH2d()); + fListHist->Add(fTRDCalibraFillHisto->GetPRF2d()); + } + if(fVdriftLinear) { + AliTRDCalibraVdriftLinearFit *fvdl = fTRDCalibraFillHisto->GetVdriftLinearFit(); + if(fvdl){ + fvdl->SetNbBindx(fVdBindx); + fvdl->SetNbBindy(fVdBindy); + fvdl->SetRangedx(fVdRangex); + fvdl->SetRangedy(fVdRangey); + } + fListHist->Add((TObject *)fTRDCalibraFillHisto->GetVdriftLinearFit()); + } + if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector + if(fExbAlt) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetExbAltFit()); + } fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain - // For testing only - if(fDebug > 2) fTRDCalibraFillHisto->SetDebugLevel(1); //debug stuff - - // output list - fListHist = new TList(); - if(fHisto2d) { - fListHist->Add(fTRDCalibraFillHisto->GetCH2d()); - fListHist->Add(fTRDCalibraFillHisto->GetPH2d()); - fListHist->Add(fTRDCalibraFillHisto->GetPRF2d()); - } - if(fVdriftLinear) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetVdriftLinearFit()); - if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector - fNEvents = new TH1I("NEvents","NEvents", 2, 0, 2); + fNEvents = new TH1I(Form("NEvents_%s",(const char*)fName),"NEvents", 2, 0, 2); fListHist->Add(fNEvents); + fNEventsInput = new TH1I(Form("NEventsInput_%s",(const char*)fName),"NEventsInput", 2, 0, 2); + fListHist->Add(fNEventsInput); // absolute gain calibration even without AliESDfriend Int_t nBinsPt = 25; @@ -313,7 +357,7 @@ void AliTRDCalibTask::UserCreateOutputObjects() for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ; for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]); - fAbsoluteGain = new TH2F("AbsoluteGain","AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt); + fAbsoluteGain = new TH2F(Form("AbsoluteGain_%s",(const char*)fName),"AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt); fAbsoluteGain->SetYTitle("Momentum at TRD"); fAbsoluteGain->SetXTitle("charge deposit [a.u]"); fAbsoluteGain->SetZTitle("counts"); @@ -321,15 +365,45 @@ void AliTRDCalibTask::UserCreateOutputObjects() fAbsoluteGain->Sumw2(); fListHist->Add(fAbsoluteGain); + if(IsPHQon()){ + printf("\n AliTRDCalibTask PHQ is on!! \n\n"); + AliTRDdEdxBaseUtils::PrintControl(); + AliTRDdEdxCalibUtils::IniHistArray(fListHist, kTRUE); + } + else{ + printf("\n AliTRDCalibTask PHQ is off!! \n\n"); + } - ///////////////////////////////////////// // First debug level /////////////////////////////////////// if(fDebug > 0) { + + fLinearVdriftTest = new TH2S(Form("LFDV0testversion_%s",(const char*)fName),"LFDV0testversion",36,-0.9,0.9,48,-1.2,1.2); + fLinearVdriftTest->SetXTitle("tan(phi_{track})"); + fLinearVdriftTest->SetYTitle("dy/dt"); + fLinearVdriftTest->SetZTitle("Number of tracklets"); + fLinearVdriftTest->SetStats(0); + fLinearVdriftTest->SetDirectory(0); // Standart with AliESDfriend - fPH2dSM = new TProfile2D("PH2dSM","Nz10Nrphi10" + fPH2dTest = new TProfile2D(Form("PH2dTest_%s",(const char*)fName),"Nz0Nrphi0" + ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0) + ,540,0,540); + fPH2dTest->SetYTitle("Det/pad groups"); + fPH2dTest->SetXTitle("time [#mus]"); + fPH2dTest->SetZTitle(" [a.u.]"); + fPH2dTest->SetStats(0); + // + fCH2dTest = new TH2I(Form("CH2dTest_%s",(const char*)fName),"Nz0Nrphi0",50,0,300,540,0,540); + fCH2dTest->SetYTitle("Det/pad groups"); + fCH2dTest->SetXTitle("charge deposit [a.u]"); + fCH2dTest->SetZTitle("counts"); + fCH2dTest->SetStats(0); + fCH2dTest->Sumw2(); + + // + fPH2dSM = new TProfile2D(Form("PH2dSM_%s",(const char*)fName),"Nz10Nrphi10" ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0) ,18,0,18); fPH2dSM->SetYTitle("Det/pad groups"); @@ -337,14 +411,14 @@ void AliTRDCalibTask::UserCreateOutputObjects() fPH2dSM->SetZTitle(" [a.u.]"); fPH2dSM->SetStats(0); // - fCH2dSM = new TH2I("CH2dSM","Nz10Nrphi10",50,0,300,18,0,18); + fCH2dSM = new TH2I(Form("CH2dSM_%s",(const char*)fName),"Nz10Nrphi10",50,0,300,18,0,18); fCH2dSM->SetYTitle("Det/pad groups"); fCH2dSM->SetXTitle("charge deposit [a.u]"); fCH2dSM->SetZTitle("counts"); fCH2dSM->SetStats(0); fCH2dSM->Sumw2(); // - fPH2dSum = new TProfile2D("PH2dSum","Nz100Nrphi100" + fPH2dSum = new TProfile2D(Form("PH2dSum_%s",(const char*)fName),"Nz100Nrphi100" ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0) ,1,0,1); fPH2dSum->SetYTitle("Det/pad groups"); @@ -352,18 +426,23 @@ void AliTRDCalibTask::UserCreateOutputObjects() fPH2dSum->SetZTitle(" [a.u.]"); fPH2dSum->SetStats(0); // - fCH2dSum = new TH2I("CH2dSum","Nz100Nrphi100",50,0,300,1,0,1); + fCH2dSum = new TH2I(Form("CH2dSum_%s",(const char*)fName),"Nz100Nrphi100",50,0,300,1,0,1); fCH2dSum->SetYTitle("Det/pad groups"); fCH2dSum->SetXTitle("charge deposit [a.u]"); fCH2dSum->SetZTitle("counts"); fCH2dSum->SetStats(0); fCH2dSum->Sumw2(); + // Add them + fListHist->Add(fLinearVdriftTest); + fListHist->Add(fPH2dTest); + fListHist->Add(fCH2dTest); fListHist->Add(fPH2dSM); fListHist->Add(fCH2dSM); fListHist->Add(fPH2dSum); fListHist->Add(fCH2dSum); + } ///////////////////////////////////////// @@ -371,36 +450,43 @@ void AliTRDCalibTask::UserCreateOutputObjects() /////////////////////////////////////// if(fDebug > 1) { - fNbTRDTrack = new TH1F("TRDTrack","TRDTrack",50,0,50); + fNbGoodTracks = new TH2F(Form("NbGoodTracks_%s",(const char*)fName),"NbGoodTracks",500,0.0,2500.0,200,0.0,100.0); + fNbGoodTracks->SetXTitle("Nb of good tracks"); + fNbGoodTracks->SetYTitle("Centrality"); + fNbGoodTracks->SetStats(0); + + fNbTRDTrack = new TH1F(Form("TRDTrack_%s",(const char*)fName),"TRDTrack",50,0,50); fNbTRDTrack->Sumw2(); - fNbTRDTrackOffline = new TH1F("TRDTrackOffline","TRDTrackOffline",50,0,50); + fNbTRDTrackOffline = new TH1F(Form("TRDTrackOffline_%s",(const char*)fName),"TRDTrackOffline",50,0,50); fNbTRDTrackOffline->Sumw2(); - fNbTRDTrackStandalone = new TH1F("TRDTrackStandalone","TRDTrackStandalone",50,0,50); + fNbTRDTrackStandalone = new TH1F(Form("TRDTrackStandalone_%s",(const char*)fName),"TRDTrackStandalone",50,0,50); fNbTRDTrackStandalone->Sumw2(); - fNbTPCTRDtrack = new TH2F("NbTPCTRDtrack","NbTPCTRDtrack",100,0,100,100,0,100); + fNbTPCTRDtrack = new TH2F(Form("NbTPCTRDtrack_%s",(const char*)fName),"NbTPCTRDtrack",100,0,100,100,0,100); fNbTPCTRDtrack->Sumw2(); // - fNbTimeBin = new TH1F("NbTimeBin","NbTimeBin",35,0,35); + fNbTimeBin = new TH1F(Form("NbTimeBin_%s",(const char*)fName),"NbTimeBin",35,0,35); fNbTimeBin->Sumw2(); - fNbTimeBinOffline = new TH1F("NbTimeBinOffline","NbTimeBinOffline",35,0,35); + fNbTimeBinOffline = new TH1F(Form("NbTimeBinOffline_%s",(const char*)fName),"NbTimeBinOffline",35,0,35); fNbTimeBinOffline->Sumw2(); - fNbTimeBinStandalone = new TH1F("NbTimeBinStandalone","NbTimeBinStandalone",35,0,35); + fNbTimeBinStandalone = new TH1F(Form("NbTimeBinStandalone_%s",(const char*)fName),"NbTimeBinStandalone",35,0,35); fNbTimeBinStandalone->Sumw2(); // - fNbClusters = new TH1F("NbClusters","",35,0,35); + fNbClusters = new TH1F(Form("NbClusters_%s",(const char*)fName),"",35,0,35); fNbClusters->Sumw2(); - fNbClustersOffline = new TH1F("NbClustersOffline","",35,0,35); + fNbClustersOffline = new TH1F(Form("NbClustersOffline_%s",(const char*)fName),"",35,0,35); fNbClustersOffline->Sumw2(); - fNbClustersStandalone = new TH1F("NbClustersStandalone","",35,0,35); + fNbClustersStandalone = new TH1F(Form("NbClustersStandalone_%s",(const char*)fName),"",35,0,35); fNbClustersStandalone->Sumw2(); // - fNbTracklets = new TH1F("NbTracklets","NbTracklets",540,0.,540.); + fNbTracklets = new TH1F(Form("NbTracklets_%s",(const char*)fName),"NbTracklets",540,0.,540.); fNbTracklets->Sumw2(); - fNbTrackletsOffline = new TH1F("NbTrackletsOffline","NbTrackletsOffline",540,0.,540.); + fNbTrackletsOffline = new TH1F(Form("NbTrackletsOffline_%s",(const char*)fName),"NbTrackletsOffline",540,0.,540.); fNbTrackletsOffline->Sumw2(); - fNbTrackletsStandalone = new TH1F("NbTrackletsStandalone","NbTrackletsStandalone",540,0.,540.); + fNbTrackletsStandalone = new TH1F(Form("NbTrackletsStandalone_%s",(const char*)fName),"NbTrackletsStandalone",540,0.,540.); fNbTrackletsStandalone->Sumw2(); + fListHist->Add(fNbGoodTracks); + fListHist->Add(fNbTRDTrack); fListHist->Add(fNbTRDTrackOffline); fListHist->Add(fNbTRDTrackStandalone); @@ -421,6 +507,8 @@ void AliTRDCalibTask::UserCreateOutputObjects() delete [] binLimLogPt; delete [] binLimPt; + PostData(1,fListHist); + //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl; } @@ -434,24 +522,50 @@ void AliTRDCalibTask::UserExec(Option_t *) //cout << "AliTRDCalibTask::Exec() IN" << endl; // Init Versions and subversions used - if((fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) { + if((fFirstRunGain==-1) || (fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fFirstRunGainLocal==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fFirstRunVdrift==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) { if(!SetVersionSubversion()) { - fVersionGainUsed=0; - fSubVersionGainUsed=0; - fVersionGainLocalUsed=0; - fSubVersionGainLocalUsed=0; - fVersionVdriftUsed=0; - fSubVersionVdriftUsed=0; + PostData(1, fListHist); + return; } } if(fCounter==0) { - fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used - fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used - fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used - fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used - fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used - fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used - fTRDCalibraFillHisto->InitCalDet(); + if(fOnInstance) { + fTRDCalibraFillHisto->SetFirstRunGain(fFirstRunGain); // Gain Used + fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used + fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used + fTRDCalibraFillHisto->SetFirstRunGainLocal(fFirstRunGainLocal); // Gain Used + fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used + fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used + fTRDCalibraFillHisto->SetFirstRunVdrift(fFirstRunVdrift); // Vdrift Used + fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used + fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used + if((fFirstRunExB != -1) && (fVersionExBUsed != -1) && (fSubVersionExBUsed != -1)){ + fTRDCalibraFillHisto->SetFirstRunExB(fFirstRunExB); // ExB Used + fTRDCalibraFillHisto->SetVersionExBUsed(fVersionExBUsed); // ExB Used + fTRDCalibraFillHisto->SetSubVersionExBUsed(fSubVersionExBUsed); // ExB Used + } + fTRDCalibraFillHisto->InitCalDet(); + } + if(fDebug > 1){ + // title CH2dTest + TString name("Ver"); + name += fVersionGainUsed; + name += "Subver"; + name += fSubVersionGainUsed; + name += "FirstRun"; + name += fFirstRunGain; + name += "Nz0Nrphi0"; + fCH2dTest->SetTitle(name); + // title PH2dTest + TString namee("Ver"); + namee += fVersionVdriftUsed; + namee += "Subver"; + namee += fSubVersionVdriftUsed; + namee += "FirstRun"; + namee += fFirstRunVdrift; + namee += "Nz0Nrphi0"; + fPH2dTest->SetTitle(namee); + } } // AliLog::SetGlobalLogLevel(AliLog::kError); @@ -462,48 +576,64 @@ void AliTRDCalibTask::UserExec(Option_t *) PostData(1, fListHist); return; } + + const char* type = fESD->GetBeamType(); + //printf("Counter %d\n",fCounter); fCounter++; + fNEventsInput->Fill(1); + //cout << "maxEvent = " << fMaxEvent << endl; //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl; - if((fMaxEvent != 0) && (fMaxEvent < fCounter)) return; + if((fMaxEvent != 0) && (fMaxEvent < fCounter)) { + PostData(1, fListHist); + return; + } //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl; //cout << "event = " << fCounter << endl; //printf("Counter %d\n",fCounter); - + /////////////////// // Check trigger /////////////////// Bool_t pass = kTRUE; - Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast(); - //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected); - if(fRejected) { - pass = kTRUE; - for(Int_t k = 0; k < numberOfTriggerSelected; k++){ - const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k); - const TString tString=obString->GetString(); - if(fESD->IsTriggerClassFired((const char*)tString)) { - pass = kFALSE; + + if (fSelectTrigger) { + + //printf("Will check the triggers\n"); + + Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast(); + //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected); + if(fRejected) { + pass = kTRUE; + for(Int_t k = 0; k < numberOfTriggerSelected; k++){ + const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k); + const TString tString=obString->GetString(); + if(fESD->IsTriggerClassFired((const char*)tString)) { + pass = kFALSE; + } } } - } - else { - pass = kFALSE; - for(Int_t k = 0; k < numberOfTriggerSelected; k++){ - const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k); - const TString tString=obString->GetString(); - if(fESD->IsTriggerClassFired((const char*)tString)) { - pass = kTRUE; + else { + pass = kFALSE; + for(Int_t k = 0; k < numberOfTriggerSelected; k++){ + const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k); + const TString tString=obString->GetString(); + if(fESD->IsTriggerClassFired((const char*)tString)) { + pass = kTRUE; + } } } + if(!pass) { + PostData(1, fListHist); + return; + } + } - if(!pass) { - PostData(1, fListHist); - return; - } + //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses()); //printf("Trigger passed\n"); @@ -533,6 +663,45 @@ void AliTRDCalibTask::UserExec(Option_t *) } //printf("Primary vertex passed\n"); + + ////////////////////////////////// + // Reject pile-up with SPD + ////////////////////////////////// + + if(fRejectPileUpWithSPD) { + if(fInputEvent->IsPileupFromSPD(3, 0.8, 3., 2., 5)){ + //printf("test\n"); + PostData(1, fListHist); + return; + } + } + + ////////////////////////////////////// + // Requirement on number of good tracks + ////////////////////////////////////// + Int_t nGoodParticles = 0; + Double_t nbTracks = fESD->GetNumberOfTracks(); + for(Int_t itrack = 0; itrack < nbTracks; itrack++) { + if(ParticleGood(itrack)) nGoodParticles++; + } + if(fDebug > 1) { + // Centrality + AliCentrality *esdCentrality = fESD->GetCentrality(); + Float_t centrality = esdCentrality->GetCentralityPercentile("V0M"); + //Float_t centralityb = esdCentrality->GetCentralityPercentile("CL1"); + fNbGoodTracks->Fill(nGoodParticles,centrality); + //printf("centrality %f, centralityb %f\n",centrality,centralityb); + } + + //printf("Beam type %s\n",(const char*)type); + if (!strstr(type,"p-p")) { + //if (strstr(type,"A-A")) { + //printf("Will check the number of good tracks %f %f %f\n",nGoodParticles,fMinNbTracks,fMaxNbTracks); + if((nGoodParticles < fMinNbTracks) || (nGoodParticles > fMaxNbTracks)) { + PostData(1, fListHist); + return; + } + } fNEvents->Fill(1); @@ -545,9 +714,8 @@ void AliTRDCalibTask::UserExec(Option_t *) // TPC Int_t nbtrackTPC = 0; - Double_t nbTracks = fESD->GetNumberOfTracks(); - //printf("Number of tracks %f\n",nbTracks); - + + if (nbTracks <= 0.0) { if(fDebug > 1) { @@ -558,59 +726,28 @@ void AliTRDCalibTask::UserExec(Option_t *) PostData(1, fListHist); return; } - - + + fESDfriend = dynamic_cast (fESD->FindListObject("AliESDfriend")); if(!fESDfriend){ AliError("fESDfriend not available"); PostData(1, fListHist); return; } - - //printf("has friends\n"); - /* - //////////////////////////////////// - // Check the number of TPC tracks - /////////////////////////////////// - //printf("Nb of tracks %f\n",nbTracks); - for(Int_t itrk = 0; itrk < nbTracks; itrk++){ - // Get ESD track - fkEsdTrack = fESD->GetTrack(itrk); - ULong_t status = fkEsdTrack->GetStatus(); - if(status&(AliESDtrack::kTPCout)) nbtrackTPC++; - if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) { - nbTrdTracks++; - nbTrdTracksStandalone++; - } - if((status&(AliESDtrack::kTRDin))) { - nbTrdTracks++; - nbTrdTracksOffline++; - } - } - - if((nbtrackTPC>0) && (nbTrdTracks > (3.0*nbtrackTPC))) pass = kFALSE; - - if(fDebug > 1) { - - fNbTRDTrack->Fill(nbTrdTracks); - fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone); - fNbTRDTrackOffline->Fill(nbTrdTracksOffline); - fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC); - - } + if(fESDfriend->TestSkipBit()) { + PostData(1, fListHist); + return; + } + + //printf("has friends\n"); - if(!pass) { - PostData(1, fListHist); - return; - } - */ - ///////////////////////////////////// // Loop on AliESDtrack //////////////////////////////////// - //printf("Nb of tracks %f\n",nbTracks); - for(int itrk=0; itrk < nbTracks; ++itrk){ + //printf("Nb of tracks %f\n",nbTracks); + Int_t nbTracksfriends = fESDfriend->GetNumberOfTracks(); + for(int itrk=0; itrk < nbTracksfriends; ++itrk){ // Get ESD track fkEsdTrack = fESD->GetTrack(itrk); @@ -618,38 +755,22 @@ void AliTRDCalibTask::UserExec(Option_t *) ULong_t status = fkEsdTrack->GetStatus(); if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC; - // Quality cuts on the AliESDtrack - if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) { - //printf("Not a good track\n"); + // Fix suggested by Alex + fFriendTrack = fESDfriend->GetTrack(itrk); + //printf("itrk %d\n",itrk); + //fFriendTrack = (fESDfriend->GetNumberOfTracks()>itrk)?fESDfriend->GetTrack(itrk):NULL; + if(!fFriendTrack) { + //printf("No friend track %d\n",itrk); continue; } - - // First Absolute gain calibration - Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets(); - Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID(); - if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) { - for(Int_t iPlane = 0; iPlane < 6; ++iPlane){ - //Double_t slide = fkEsdTrack->GetTRDslice(iPlane); - //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices()); - //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane); - //printf("momentum %f, slide %f\n",momentum,slide); - if(fkEsdTrack->GetTRDslice(iPlane) > 0.0) - fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0, - fkEsdTrack->GetTRDmomentum(iPlane)); - } - } - + // Other cuts + fTrdTrack = 0x0; Bool_t good = kTRUE; Bool_t standalonetrack = kFALSE; Bool_t offlinetrack = kFALSE; //ULong_t status = fkEsdTrack->GetStatus(); - fFriendTrack = fESDfriend->GetTrack(itrk); - if(!fFriendTrack) { - //printf("No friend track %d\n",itrk); - continue; - } ////////////////////////////////////// // Loop on calibration objects ////////////////////////////////////// @@ -679,131 +800,173 @@ void AliTRDCalibTask::UserExec(Option_t *) } fTrdTrack = (AliTRDtrackV1 *)fCalibObject; - if(good) { - //cout << "good" << endl; - fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack); - //printf("Fill fTRDCalibraFillHisto\n"); + // process chamberstatus + fTRDChamberStatus->ProcessTrack(fTrdTrack); + } + + // Quality cuts on the AliESDtrack + if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) { + //printf("Not a good track\n"); + continue; + } + + // First Absolute gain calibration + Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets(); + Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID(); + //printf("Number of trd tracklets %d and PID trd tracklets %d\n",trdNTracklets,trdNTrackletsPID); + if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) { + for(Int_t iPlane = 0; iPlane < 6; ++iPlane){ + //Double_t slide = fkEsdTrack->GetTRDslice(iPlane); + //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices()); + //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane); + //printf("momentum %f, slide %f\n",momentum,slide); + if(fkEsdTrack->GetTRDslice(iPlane) > 0.0) + fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0, + fkEsdTrack->GetTRDmomentum(iPlane)); } + } + + + if(!fTrdTrack) continue; + + if(good && fOnInstance) { + //cout << "good" << endl; + fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack,fkEsdTrack); + //printf("Fill fTRDCalibraFillHisto\n"); + } + + if(IsPHQon()){ + const Double_t mag = AliTRDdEdxBaseUtils::IsExBOn() ? fESD->GetMagneticField() : -1; + const Int_t charge = AliTRDdEdxBaseUtils::IsExBOn() ? fkEsdTrack->Charge() : -1; + const Double_t toTPCscale = AliTRDdEdxCalibUtils::GetCalibTPCscale(fkEsdTrack->GetTPCncls(), fkEsdTrack->GetTPCsignal()); + if(toTPCscale>0){ + AliTRDdEdxCalibUtils::FillHist(fTrdTrack, 0, mag, charge, toTPCscale); + } + } + + ////////////////////////////////// + // Debug + //////////////////////////////// + + if(fDebug > 0) { - ////////////////////////////////// - // Debug - //////////////////////////////// + //printf("Enter debug\n"); - if(fDebug > 0) { + Int_t nbtracklets = 0; + + // Check some stuff + Bool_t standalonetracklet = kFALSE; + const AliTRDseedV1 *tracklet = 0x0; + ////////////////////////////////////// + // Loop tracklets + ///////////////////////////////////// + Int_t nbclusters=0; + Double_t phtb[AliTRDseedV1::kNtb]; + memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t)); + Double_t sum = 0.0; + Float_t normalisation = 1.13; + Int_t detector = 0; + Int_t sector = 0; + for(Int_t itr = 0; itr < 6; ++itr){ - //printf("Enter debug\n"); + if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue; + if(!tracklet->IsOK()) continue; + ++nbtracklets; + standalonetracklet = kFALSE; + if(tracklet->IsStandAlone()) standalonetracklet = kTRUE; - Int_t nbtracklets = 0; + nbclusters = 0; + memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t)); + sum = 0.0; + detector = 0; + sector = 0; + //Int_t crossrow = 0; - // Check some stuff - Bool_t standalonetracklet = kFALSE; - const AliTRDseedV1 *tracklet = 0x0; - ////////////////////////////////////// - // Loop tracklets - ///////////////////////////////////// - Int_t nbclusters=0; - Double_t phtb[AliTRDseedV1::kNtb]; - memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t)); - Double_t sum = 0.0; - Float_t normalisation = 6.67; - Int_t detector = 0; - Int_t sector = 0; - for(Int_t itr = 0; itr < 6; ++itr){ - - if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue; - if(!tracklet->IsOK()) continue; - ++nbtracklets; - standalonetracklet = kFALSE; - if(tracklet->IsStandAlone()) standalonetracklet = kTRUE; - - nbclusters = 0; - memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t)); - sum = 0.0; - detector = 0; - sector = 0; - //Int_t crossrow = 0; - // Check no shared clusters //for(int icc=AliTRDseedV1::kNtb; iccGetClusters(icc))) crossrow = 1; // } - + // Loop on clusters - Int_t time = 0; - Float_t ch = 0; - Float_t qcl = 0; - for(int ic=0; icGetClusters(ic))) continue; - ++nbclusters; - time = fCl->GetPadTime(); - ch = tracklet->GetdQdl(ic); - qcl = TMath::Abs(fCl->GetQ()); - detector = fCl->GetDetector(); - // Add the charge if shared cluster - if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) { - if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) { - qcl += TMath::Abs(fCl->GetQ()); - //printf("Add the cluster charge\n"); - } - } - if((time>-1) && (timeGetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation; - else sum += ch/normalisation; - - if(fDebug > 1) { - fNbTimeBin->Fill(time); - if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time); - else fNbTimeBinOffline->Fill(time); + Int_t time = 0; + Float_t ch = 0; + Float_t qcl = 0; + for(int ic=0; icGetClusters(ic))) continue; + ++nbclusters; + time = fCl->GetPadTime(); + //ch = tracklet->GetdQdl(ic); + ch = tracklet->GetQperTB(ic); + qcl = TMath::Abs(fCl->GetQ()); + detector = fCl->GetDetector(); + // Add the charge if shared cluster + if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) { + if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) { + qcl += TMath::Abs(fCl->GetQ()); + //printf("Add the cluster charge\n"); } } - sector = AliTRDgeometry::GetSector(detector); + if((time>-1) && (timeGetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation; + else sum += ch/normalisation; if(fDebug > 1) { - fNbTracklets->Fill(detector); - if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector); - else fNbTrackletsOffline->Fill(detector); - - fNbClusters->Fill(nbclusters); - if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters); - else fNbClustersOffline->Fill(nbclusters); - } + fNbTimeBin->Fill(time); + if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time); + else fNbTimeBinOffline->Fill(time); + } + } + sector = AliTRDgeometry::GetSector(detector); + + if(fDebug > 1) { + fNbTracklets->Fill(detector); + if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector); + else fNbTrackletsOffline->Fill(detector); - if(fDebug > 0) { - if((nbclusters > fLow) && (nbclusters < fHigh)){ - if(fRelativeScale > 0.0) sum = sum/fRelativeScale; - fCH2dSM->Fill(sum,sector+0.5); - fCH2dSum->Fill(sum,0.5); - Bool_t checknoise = kTRUE; - if(fMaxCluster > 0) { - if(phtb[0] > fMaxCluster) checknoise = kFALSE; - if(fNbTimeBins > fNbMaxCluster) { - for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){ - if(phtb[k] > fMaxCluster) checknoise = kFALSE; - } - } + fNbClusters->Fill(nbclusters); + if(tracklet->IsStandAlone()) fNbClustersStandalone->Fill(nbclusters); + else fNbClustersOffline->Fill(nbclusters); + } + + if((nbclusters > fLow) && (nbclusters < fHigh)){ + if(fRelativeScale > 0.0) sum = sum/fRelativeScale; + fCH2dTest->Fill(sum,detector+0.5); + fCH2dSM->Fill(sum,sector+0.5); + fCH2dSum->Fill(sum,0.5); + Bool_t checknoise = kTRUE; + if(fMaxCluster > 0) { + if(phtb[0] > fMaxCluster) checknoise = kFALSE; + if(fNbTimeBins > fNbMaxCluster) { + for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){ + if(phtb[k] > fMaxCluster) checknoise = kFALSE; + } + } + } + if(checknoise) { + for(int ic=0; icFill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]); + fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]); + fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]); } - if(checknoise) { - for(int ic=0; icFill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]); - fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]); - } - else { - if(phtb[ic] > 0.0) { - fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]); - fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]); - } - } + else { + if(phtb[ic] > 0.0) { + fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]); + fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]); + fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]); } } } } - } // loop on tracklets + } + if(detector == 0) FindP1TrackPHtrackletV1Test(tracklet,nbclusters); - } // debug + } // loop on tracklets + - }// while calibration objects + } // debug + if(nTRDtrackV1 > 0) { ++nbTrdTracks; if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) { @@ -869,201 +1032,6 @@ Bool_t AliTRDCalibTask::Load(TList *lister) fListHist = (TList*)lister->Clone(GetName()); return kTRUE; } -//________________________________________________________________________ -void AliTRDCalibTask::Plot() -{ - // - // Plot the histos stored in the TList - // - - if(!fListHist) return; - - ///////////////////////////////////// - // Take the debug stuff - ///////////////////////////////////// - - TH1I *nEvents = (TH1I *) fListHist->FindObject("NEvents"); - - TH2F *absoluteGain = (TH2F *) fListHist->FindObject("AbsoluteGain"); - - TH1F *trdTrack = (TH1F *) fListHist->FindObject("TRDTrack"); - TH1F *trdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline"); - TH1F *trdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone"); - - TH2F *tpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack"); - - TH1F *nbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin"); - TH1F *nbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline"); - TH1F *nbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone"); - - TH1F *nbClusters = (TH1F *) fListHist->FindObject("NbClusters"); - TH1F *nbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline"); - TH1F *nbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone"); - - TH1F *nbTracklets = (TH1F *) fListHist->FindObject("NbTracklets"); - TH1F *nbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline"); - TH1F *nbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone"); - - ///////////////////////////////////// - // Take the calibration objects - ///////////////////////////////////// - - TH2I *ch2d = (TH2I *) fListHist->FindObject("CH2d"); - TProfile2D *ph2d = (TProfile2D *) fListHist->FindObject("PH2d"); - - TH2I *ch2dSum = (TH2I *) fListHist->FindObject("CH2dSum"); - TProfile2D *ph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum"); - - TH2I *ch2dSM = (TH2I *) fListHist->FindObject("CH2dSM"); - TProfile2D *ph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM"); - - AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit"); - - //////////////////////////////////////////////// - // Add the AliTRDCalibraVdriftLinearFit - /////////////////////////////////////////////// - - Int_t first = 0; - TH2S *histolinearfitsum = 0x0; - - if(linearfit) { - for(Int_t det = 0; det < 540; det++) { - if(linearfit->GetLinearFitterHisto(det)){ - if(TMath::Abs(first)<0.0001){ - histolinearfitsum = linearfit->GetLinearFitterHisto(det); - first += 1; - } - else { - if (histolinearfitsum) { - histolinearfitsum->Add(linearfit->GetLinearFitterHisto(det)); - } - } - } - } - } - - /////////////////////////// - // Style - ////////////////////////// - - gStyle->SetPalette(1); - gStyle->SetOptStat(1111); - gStyle->SetOptFit(1111); - gStyle->SetPadBorderMode(0); - gStyle->SetCanvasColor(10); - gStyle->SetPadLeftMargin(0.13); - gStyle->SetPadRightMargin(0.13); - - ///////////////////////// - // Plot - //////////////////////// - - if(nEvents) { - - TCanvas *debugEvents = new TCanvas("cNEvents","cNEvents",10,10,510,510); - debugEvents->cd(1); - if(nEvents) nEvents->Draw(); - - } - - if(absoluteGain) { - - TCanvas *debugAbsoluteGain = new TCanvas("cAbsoluteGain","cAbsoluteGain",10,10,510,510); - debugAbsoluteGain->cd(1); - if(absoluteGain) absoluteGain->Draw(); - - } - - if(trdTrack || tpctrdTrack) { - - TCanvas *debugtrdtpcTrack = new TCanvas("TRDtracktpctrdtrack","TRDtracktpctrdtrack",10,10,510,510); - debugtrdtpcTrack->Divide(2,1); - debugtrdtpcTrack->cd(1); - if(trdTrack) trdTrack->Draw(); - if(trdTrackOffline) trdTrackOffline->Draw("same"); - if(trdTrackStandalone) trdTrackStandalone->Draw("same"); - TLegend *leg = new TLegend(0.4,0.6,0.89,0.89); - if(trdTrack) leg->AddEntry(trdTrack,"All","p"); - if(trdTrackOffline) leg->AddEntry(trdTrackOffline,"Offline","p"); - if(trdTrackStandalone) leg->AddEntry(trdTrackStandalone,"Standalone","p"); - leg->Draw("same"); - debugtrdtpcTrack->cd(2); - if(tpctrdTrack) tpctrdTrack->Draw(); - TLine *line = new TLine(0.0,0.0,100.0,100.0); - line->Draw("same"); - - } - - if(nbTimeBin || nbTracklets || nbClusters) { - - TCanvas *debugTracklets = new TCanvas("TRDtimebintrackletcluster","TRDtimebintrackletcluster",10,10,510,510); - debugTracklets->Divide(3,1); - debugTracklets->cd(1); - if(nbTimeBin) nbTimeBin->Draw(); - if(nbTimeBinOffline) nbTimeBinOffline->Draw("same"); - if(nbTimeBinStandalone) nbTimeBinStandalone->Draw("same"); - TLegend *lega = new TLegend(0.4,0.6,0.89,0.89); - if(nbTimeBin) lega->AddEntry(nbTimeBin,"All","p"); - if(nbTimeBinOffline) lega->AddEntry(nbTimeBinOffline,"Offline","p"); - if(nbTimeBinStandalone) lega->AddEntry(nbTimeBinStandalone,"Standalone","p"); - lega->Draw("same"); - debugTracklets->cd(2); - if(nbTracklets) nbTracklets->Draw(); - if(nbTrackletsOffline) nbTrackletsOffline->Draw("same"); - if(nbTrackletsStandalone) nbTrackletsStandalone->Draw("same"); - TLegend *legb = new TLegend(0.4,0.6,0.89,0.89); - if(nbTracklets) legb->AddEntry(nbTracklets,"All","p"); - if(nbTrackletsOffline) legb->AddEntry(nbTrackletsOffline,"Offline","p"); - if(nbTrackletsStandalone) legb->AddEntry(nbTrackletsStandalone,"Standalone","p"); - legb->Draw("same"); - debugTracklets->cd(3); - if(nbClusters) nbClusters->Draw(); - if(nbClustersOffline) nbClustersOffline->Draw("same"); - if(nbClustersStandalone) nbClustersStandalone->Draw("same"); - TLegend *legc = new TLegend(0.4,0.6,0.89,0.89); - if(nbClusters) legc->AddEntry(nbClusters,"All","p"); - if(nbClustersOffline) legc->AddEntry(nbClustersOffline,"Offline","p"); - if(nbClustersStandalone) legc->AddEntry(nbClustersStandalone,"Standalone","p"); - legc->Draw("same"); - - } - - if(ch2dSum || ph2dSum || histolinearfitsum) { - - TCanvas *debugSum = new TCanvas("SumCalibrationObjects","SumCalibrationObjects",10,10,510,510); - debugSum->Divide(3,1); - debugSum->cd(1); - if(ch2dSum) ch2dSum->Draw("lego"); - debugSum->cd(2); - if(ph2dSum) ph2dSum->Draw("lego"); - debugSum->cd(3); - if(histolinearfitsum) histolinearfitsum->Draw(); - - } - - if(ch2dSM || ph2dSM) { - - TCanvas *debugSM = new TCanvas("SMCalibrationObjects","SMCalibrationObjects",10,10,510,510); - debugSM->Divide(2,1); - debugSM->cd(1); - if(ch2dSM) ch2dSM->Draw("lego"); - debugSM->cd(2); - if(ph2dSM) ph2dSM->Draw("lego"); - - } - - if(ch2d || ph2d) { - - TCanvas *debug = new TCanvas("CalibrationObjects","CalibrationObjects",10,10,510,510); - debug->Divide(2,1); - debug->cd(1); - if(ch2d) ch2d->Draw("lego"); - debug->cd(2); - if(ph2d) ph2d->Draw("lego"); - - } - -} //_______________________________________________________________________________________ void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) { @@ -1074,78 +1042,110 @@ void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) { TList *listcalibTask = calibTask->GetList(); if(!listcalibTask) return; - TH1I *nEvents = (TH1I *) listcalibTask->FindObject("NEvents"); - TH2F *absoluteGain = (TH2F *) listcalibTask->FindObject("AbsoluteGain"); + THnSparseI *histoEntries = (THnSparseI *) listcalibTask->FindObject("NumberOfEntries"); - TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack"); - TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject("TRDTrackOffline"); - TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject("TRDTrackStandalone"); + TH1I *nEvents = (TH1I *) listcalibTask->FindObject(Form("NEvents_%s",(const char*)calibTask->GetName())); + TH1I *nEventsInput = (TH1I *) listcalibTask->FindObject(Form("NEventsInput_%s",(const char*)calibTask->GetName())); + TH2F *absoluteGain = (TH2F *) listcalibTask->FindObject(Form("AbsoluteGain_%s",(const char*)calibTask->GetName())); - TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject("NbTPCTRDtrack"); + TH1F *trdTrack = (TH1F *) listcalibTask->FindObject(Form("TRDTrack_%s",(const char*)calibTask->GetName())); + TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject(Form("TRDTrackOffline_%s",(const char*)calibTask->GetName())); + TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject(Form("TRDTrackStandalone_%s",(const char*)calibTask->GetName())); - TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject("NbTimeBin"); - TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject("NbTimeBinOffline"); - TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject("NbTimeBinStandalone"); + TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject(Form("NbTPCTRDtrack_%s",(const char*)calibTask->GetName())); - TH1F *nbClusters = (TH1F *) listcalibTask->FindObject("NbClusters"); - TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject("NbClustersOffline"); - TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject("NbClustersStandalone"); + TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject(Form("NbTimeBin_%s",(const char*)calibTask->GetName())); + TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinOffline_%s",(const char*)calibTask->GetName())); + TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinStandalone_%s",(const char*)calibTask->GetName())); - TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject("NbTracklets"); - TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject("NbTrackletsOffline"); - TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject("NbTrackletsStandalone"); + TH1F *nbClusters = (TH1F *) listcalibTask->FindObject(Form("NbClusters_%s",(const char*)calibTask->GetName())); + TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject(Form("NbClustersOffline_%s",(const char*)calibTask->GetName())); + TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject(Form("NbClustersStandalone_%s",(const char*)calibTask->GetName())); + + TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject(Form("NbTracklets_%s",(const char*)calibTask->GetName())); + TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsOffline_%s",(const char*)calibTask->GetName())); + TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsStandalone_%s",(const char*)calibTask->GetName())); TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d"); TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d"); TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d"); - TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject("CH2dSum"); - TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject("PH2dSum"); + TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject(Form("CH2dSum_%s",(const char*)calibTask->GetName())); + TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSum_%s",(const char*)calibTask->GetName())); - TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject("CH2dSM"); - TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject("PH2dSM"); + TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject(Form("CH2dSM_%s",(const char*)calibTask->GetName())); + TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSM_%s",(const char*)calibTask->GetName())); AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit"); + AliTRDCalibraExbAltFit *exbaltfit = (AliTRDCalibraExbAltFit *) listcalibTask->FindObject("AliTRDCalibraExbAltFit"); AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector"); // - TH1I *inEvents = (TH1I *) fListHist->FindObject("NEvents"); - TH2F *iabsoluteGain = (TH2F *) fListHist->FindObject("AbsoluteGain"); + THnSparseI *inhistoEntries = (THnSparseI *) fListHist->FindObject("NumberOfEntries"); + + TH1I *inEventsInput = (TH1I *) fListHist->FindObject(Form("NEventsInput_%s",(const char*)fName)); + TH1I *inEvents = (TH1I *) fListHist->FindObject(Form("NEvents_%s",(const char*)fName)); + TH2F *iabsoluteGain = (TH2F *) fListHist->FindObject(Form("AbsoluteGain_%s",(const char*)fName)); - TH1F *itrdTrack = (TH1F *) fListHist->FindObject("TRDTrack"); - TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline"); - TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone"); + TH1F *itrdTrack = (TH1F *) fListHist->FindObject(Form("TRDTrack_%s",(const char*)fName)); + TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject(Form("TRDTrackOffline_%s",(const char*)fName)); + TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject(Form("TRDTrackStandalone_%s",(const char*)fName)); - TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack"); + TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject(Form("NbTPCTRDtrack_%s",(const char*)fName)); - TH1F *inbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin"); - TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline"); - TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone"); + TH1F *inbTimeBin = (TH1F *) fListHist->FindObject(Form("NbTimeBin_%s",(const char*)fName)); + TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject(Form("NbTimeBinOffline_%s",(const char*)fName)); + TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject(Form("NbTimeBinStandalone_%s",(const char*)fName)); - TH1F *inbClusters = (TH1F *) fListHist->FindObject("NbClusters"); - TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline"); - TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone"); + TH1F *inbClusters = (TH1F *) fListHist->FindObject(Form("NbClusters_%s",(const char*)fName)); + TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject(Form("NbClustersOffline_%s",(const char*)fName)); + TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject(Form("NbClustersStandalone_%s",(const char*)fName)); - TH1F *inbTracklets = (TH1F *) fListHist->FindObject("NbTracklets"); - TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline"); - TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone"); + TH1F *inbTracklets = (TH1F *) fListHist->FindObject(Form("NbTracklets_%s",(const char*)fName)); + TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject(Form("NbTrackletsOffline_%s",(const char*)fName)); + TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject(Form("NbTrackletsStandalone_%s",(const char*)fName)); TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d"); TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d"); TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d"); - TH2I *ich2dSum = (TH2I *) fListHist->FindObject("CH2dSum"); - TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum"); + TH2I *ich2dSum = (TH2I *) fListHist->FindObject(Form("CH2dSum_%s",(const char*)fName)); + TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject(Form("PH2dSum_%s",(const char*)fName)); - TH2I *ich2dSM = (TH2I *) fListHist->FindObject("CH2dSM"); - TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM"); + TH2I *ich2dSM = (TH2I *) fListHist->FindObject(Form("CH2dSM_%s",(const char*)fName)); + TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject(Form("PH2dSM_%s",(const char*)fName)); AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit"); + AliTRDCalibraExbAltFit *iexbaltfit = (AliTRDCalibraExbAltFit *) fListHist->FindObject("AliTRDCalibraExbAltFit"); AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector"); // Add + + if(histoEntries) { + if(inhistoEntries) { + inhistoEntries->Add(histoEntries); + //printf("Add Events\n"); + } + else { + //printf("Create new Events\n"); + inhistoEntries = (THnSparseI *) histoEntries->Clone(); + fListHist->Add(inhistoEntries); + } + } + + if(nEventsInput) { + if(inEventsInput) { + inEventsInput->Add(nEventsInput); + //printf("Add Events\n"); + } + else { + //printf("Create new Events\n"); + inEventsInput = new TH1I(*nEventsInput); + fListHist->Add(inEventsInput); + } + } if(nEvents) { if(inEvents) { @@ -1333,7 +1333,15 @@ void AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) { ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit); fListHist->Add(ilinearfit); } - } + } + + if(exbaltfit) { + if(iexbaltfit) iexbaltfit->Add(exbaltfit); + else { + iexbaltfit = new AliTRDCalibraExbAltFit(*exbaltfit); + fListHist->Add(iexbaltfit); + } + } if(calibraVector) { if(icalibraVector) icalibraVector->Add(calibraVector); @@ -1374,7 +1382,7 @@ Bool_t AliTRDCalibTask::SetVersionSubversion(){ // Load Chamber Gain factors into the Tender supply // - printf("SetVersionSubversion\n"); + //printf("SetVersionSubversion\n"); //find previous entry from the UserInfo TTree *tree=((TChain*)GetInputData(0))->GetTree(); @@ -1402,30 +1410,191 @@ Bool_t AliTRDCalibTask::SetVersionSubversion(){ if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){ // Get Old gain calibration AliCDBId *id=AliCDBId::MakeFromString(os->GetString()); + fFirstRunGain = id->GetFirstRun(); fVersionGainUsed = id->GetVersion(); fSubVersionGainUsed = id->GetSubVersion(); } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){ // Get Old drift velocity calibration AliCDBId *id=AliCDBId::MakeFromString(os->GetString()); + fFirstRunVdrift = id->GetFirstRun(); fVersionVdriftUsed = id->GetVersion(); fSubVersionVdriftUsed = id->GetSubVersion(); } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){ // Get Old drift velocity calibration AliCDBId *id=AliCDBId::MakeFromString(os->GetString()); + fFirstRunGainLocal = id->GetFirstRun(); fVersionGainLocalUsed = id->GetVersion(); fSubVersionGainLocalUsed = id->GetSubVersion(); + } else if((os->GetString().Contains("TRD/Calib/ChamberExB")) && (!os->GetString().Contains("TRD/Calib/ChamberExBAlt"))){ + // Get Old drift velocity calibration + AliCDBId *id=AliCDBId::MakeFromString(os->GetString()); + fFirstRunExB = id->GetFirstRun(); + fVersionExBUsed = id->GetVersion(); + fSubVersionExBUsed = id->GetSubVersion(); + //printf("Version %d and subversion %d\n",fVersionExBUsed,fSubVersionExBUsed); } } //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed); // Check - if((fVersionGainUsed < 0) || (fVersionGainLocalUsed < 0) || (fSubVersionGainUsed < 0) || (fSubVersionGainLocalUsed < 0) || (fVersionVdriftUsed < 0) || (fSubVersionVdriftUsed < 0)) { + if((fFirstRunGain < 0) || + (fFirstRunGainLocal < 0) || + (fFirstRunVdrift < 0) || + (fVersionGainUsed < 0) || + (fVersionGainLocalUsed < 0) || + (fSubVersionGainUsed < 0) || + (fSubVersionGainLocalUsed < 0) || + (fVersionVdriftUsed < 0) || + (fSubVersionVdriftUsed < 0)) { AliError("No recent calibration found"); return kFALSE; } else return kTRUE; } +//_________________________________________________________________________________________________________________________ +Bool_t AliTRDCalibTask::ParticleGood(int i) const { + + // + // Definition of good tracks + // + + + AliESDtrack *track = fESD->GetTrack(i); + if (!track->IsOn(AliESDtrack::kTPCrefit)) return 0; // TPC refit + if (track->GetTPCNcls() < 90) return 0; // number of TPC clusters + if (fabs(track->Eta())>0.8) return 0; // fiducial pseudorapidity + Float_t r,z; + track->GetImpactParametersTPC(r,z); + if (fabs(z)>2.0) return 0; // impact parameter in z + if (fabs(r)>2.0) return 0; // impact parameter in xy + if (r==0) return 0; + return 1; + + +} +//______________________________________________________________________________________________________________________ +Bool_t AliTRDCalibTask::FindP1TrackPHtrackletV1Test(const AliTRDseedV1 *tracklet, Int_t nbclusters) +{ + // + // 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 + ///////////////////////////////////////////////// + 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 + TLinearFitter linearFitterTracklet(2,"pol1"); + linearFitterTracklet.StoreData(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; + ////////////////////////////// + // Check no shared clusters + ////////////////////////////// + for(int icc=AliTRDseedV1::kNtb; iccGetClusters(icc); + if(cl) crossrow = 1; + } + ////////////////////////////////// + // Loop clusters + ////////////////////////////////// + for(int ic=0; icGetClusters(ic))) continue; + //if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue; + + Double_t ycluster = cl->GetY(); + Int_t time = cl->GetPadTime(); + Double_t timeis = time/10.0; + //See if cross two pad rows + Int_t row = cl->GetPadRow(); + if(rowp==-1) rowp = row; + if(row != rowp) crossrow = 1; + + linearFitterTracklet.AddPoint(&timeis,ycluster,1); + nbli++; + + + } + + //////////////////////////////////// + // Do the straight line fit now + /////////////////////////////////// + if(nbli <= 2){ + linearFitterTracklet.ClearPoints(); + return kFALSE; + } + TVectorD pars; + linearFitterTracklet.Eval(); + linearFitterTracklet.GetParameters(pars); + pointError = TMath::Sqrt(linearFitterTracklet.GetChisquare()/(nbli-2)); + errorpar = linearFitterTracklet.GetParError(1)*pointError; + dydt = pars[1]; + //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",linearFitterTracklet->GetChisquare(),nbli,pointError,linearFitterTracklet->GetParError(1),errorpar); + linearFitterTracklet.ClearPoints(); + + ///////////////////////// + // Cuts quality + //////////////////////// + + if(nbclusters < fLow) return kFALSE; + if(nbclusters > fHigh) return kFALSE; + if(pointError >= 0.3) return kFALSE; + if(crossrow == 1) return kTRUE; + + /////////////////////// + // Fill + ////////////////////// + + if(fDebug > 0){ + //Add to the linear fitter of the detector + if( TMath::Abs(snp) < 1.){ + Double_t x = tnp-dzdx*tnt; + //if(!fLinearVdriftTest) printf("Not there\n"); + Double_t nbentries = fLinearVdriftTest->GetEntries(); + if(nbentries < (5.0*32767)) fLinearVdriftTest->Fill(x,dydt); + } + } + + return kTRUE; +}