* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
+//
+// static dNdPt helper functions
+//
+// basic functionality to select events and tracks
+// for dNdPt analysis
+//
+// Origin: Jan Fiete Grosse-Oetringhaus
+// Modified and Extended: Jacek Otwinowski 19/11/2009
+//
+//
#include <TROOT.h>
-#include <TParticle.h>
-#include <TParticlePDG.h>
+#include <TCanvas.h>
+#include <TF1.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>
-#include <TCanvas.h>
-#include <TList.h>
-#include <TTree.h>
-#include <TBranch.h>
-#include <TLeaf.h>
-#include <TArrayI.h>
-#include <TF1.h>
#include <AliHeader.h>
#include <AliStack.h>
-#include <AliLog.h>
-
#include <AliLog.h>
#include <AliESD.h>
#include <AliESDEvent.h>
#include <AliMCEvent.h>
#include <AliESDVertex.h>
#include <AliVertexerTracks.h>
-
-#include <AliGenEventHeader.h>
-#include <AliGenPythiaEventHeader.h>
-#include <AliGenCocktailEventHeader.h>
-#include <AliGenDPMjetEventHeader.h>
-
#include <AliMathBase.h>
#include <AliESDtrackCuts.h>
+#include <AliTracker.h>
#include "dNdPt/AlidNdPtEventCuts.h"
#include "dNdPt/AlidNdPtAcceptanceCuts.h"
#include "dNdPt/AlidNdPtHelper.h"
ClassImp(AlidNdPtHelper)
//____________________________________________________________________
-const AliESDVertex* AlidNdPtHelper::GetVertex(AliESDEvent* aEsd, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts, AnalysisMode analysisMode, Bool_t debug, Bool_t bRedoTPC, Bool_t bUseMeanVertex)
+const AliESDVertex* AlidNdPtHelper::GetVertex(AliESDEvent* const aEsd, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts, AnalysisMode analysisMode, Bool_t debug, Bool_t bRedoTPC, Bool_t bUseMeanVertex)
{
// Get the vertex from the ESD and returns it if the vertex is valid
//
const AliESDVertex* vertex = 0;
AliESDVertex *initVertex = 0;
- if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx ||
- analysisMode == kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon ||
- analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus )
+ if (analysisMode == kSPD || analysisMode == kTPCITS ||
+ analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate || analysisMode == kTPCITSHybrid)
{
vertex = aEsd->GetPrimaryVertexSPD();
if (debug)
Printf("AlidNdPtHelper::GetVertex: Returning SPD vertex");
}
- else if (analysisMode == kTPC || analysisMode == kMCRec ||
- analysisMode == kMCPion || analysisMode == kMCKaon || analysisMode == kMCProton ||
- analysisMode == kPlus || analysisMode == kMinus)
+ else if (analysisMode == kTPC)
{
if(bRedoTPC) {
for (Int_t i=0; i<aEsd->GetNumberOfTracks(); i++) {
AliESDtrack *t = aEsd->GetTrack(i);
- t->RelateToVertexTPC(vTPC, kBz, kVeryBig);
+ if(!t) continue;
+
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ t->RelateToVertexTPCBxByBz(vTPC, b, kVeryBig);
}
delete vTPC;
}
vertex = aEsd->GetPrimaryVertexTPC();
if (debug)
- Printf("AlidNdPtHelper::GetVertex: Returning vertex from tracks");
- }
- else
- Printf("AlidNdPtHelper::GetVertex: ERROR: Invalid second argument %d", analysisMode);
+ Printf("AlidNdPtHelper::GetVertex: Returning vertex from tracks");
+ }
+ else
+ Printf("AlidNdPtHelper::GetVertex: ERROR: Invalid second argument %d", analysisMode);
if (!vertex) {
if (debug)
{
// Checks if a vertex meets the needed quality criteria
if(!vertex) return kFALSE;
+ if(!vertex->GetStatus()) return kFALSE;
Float_t requiredZResolution = -1;
- if (analysisMode == kSPD || analysisMode == kTPCITS || analysisMode == kTPCSPDvtx)
+ if (analysisMode == kSPD || analysisMode == kTPCITS ||
+ analysisMode == kTPCSPDvtx || analysisMode == kTPCSPDvtxUpdate || analysisMode == kTPCITSHybrid)
{
- requiredZResolution = 0.1;
+ requiredZResolution = 1000;
}
- else if (analysisMode == kTPC || analysisMode == kMCRec ||
- analysisMode == kMCPion || analysisMode == kMCKaon ||
- analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus)
+ else if (analysisMode == kTPC)
requiredZResolution = 10.;
+ // check resolution
+ Double_t zRes = vertex->GetZRes();
+
+ if (zRes > requiredZResolution) {
+ if (debug)
+ Printf("AlidNdPtHelper::TestVertex: Resolution too poor %f (required: %f", zRes, requiredZResolution);
+ return kFALSE;
+ }
+
+ if (vertex->IsFromVertexerZ())
+ {
+ if (vertex->GetDispersion() > 0.02)
+ {
+ if (debug)
+ Printf("AliPWG0Helper::TestVertex: Delta Phi too large in Vertexer Z: %f (required: %f", vertex->GetDispersion(), 0.02);
+ return kFALSE;
+ }
+ }
+
+ /*
// check Ncontributors
if (vertex->GetNContributors() <= 0) {
if (debug){
}
return kFALSE;
}
-
- // check resolution
- Double_t zRes = vertex->GetZRes();
- if (zRes == 0) {
- Printf("AlidNdPtHelper::GetVertex: UNEXPECTED: resolution is 0.");
- return kFALSE;
- }
-
- if (zRes > requiredZResolution) {
- if (debug)
- Printf("AlidNdPtHelper::TestVertex: Resolution too poor %f (required: %f", zRes, requiredZResolution);
- return kFALSE;
- }
+ */
return kTRUE;
}
//____________________________________________________________________
-Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* stack, Int_t idx, AnalysisMode analysisMode)
+Bool_t AlidNdPtHelper::IsPrimaryParticle(AliStack* const stack, Int_t idx, ParticleMode particleMode)
{
+//
// check primary particles
-// depending on the analysis mode
+// depending on the particle mode
//
if(!stack) return kFALSE;
// only charged particles
Double_t charge = particle->GetPDG()->Charge()/3.;
- if (charge == 0.0) return kFALSE;
+ if (TMath::Abs(charge) < 0.001) return kFALSE;
Int_t pdg = TMath::Abs(particle->GetPdgCode());
// physical primary
Bool_t prim = stack->IsPhysicalPrimary(idx);
- if(analysisMode==kMCPion) {
+ if(particleMode==kMCPion) {
if(prim && pdg==kPiPlus) return kTRUE;
else return kFALSE;
}
- if (analysisMode==kMCKaon) {
+ if (particleMode==kMCKaon) {
if(prim && pdg==kKPlus) return kTRUE;
else return kFALSE;
}
- if (analysisMode==kMCProton) {
+ if (particleMode==kMCProton) {
if(prim && pdg==kProton) return kTRUE;
else return kFALSE;
}
}
//____________________________________________________________________
-void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliPWG0Helper::Trigger trigger)
+Bool_t AlidNdPtHelper::IsCosmicTrack(AliESDtrack *const track1, AliESDtrack *const track2)
+{
+//
+// check cosmic tracks
+//
+ if(!track1) return kFALSE;
+ if(!track2) return kFALSE;
+
+ //
+ // cosmic tracks in TPC
+ //
+ //if( TMath::Abs( track1->Theta() - track2->Theta() ) < 0.004 &&
+ // ((TMath::Abs(track1->Phi()-track2->Phi()) - TMath::Pi() )<0.004) &&
+ //if( track1->Pt() > 4.0 && (TMath::Abs(track1->Phi()-track2->Phi())-TMath::Pi())<0.1
+ // && (TMath::Abs(track1->Eta()+track2->Eta())-0.1) < 0.0 && (track1->Charge()+track2->Charge()) == 0)
+
+ //Float_t scaleF= 6.0;
+ if ( track1->Pt() > 4 && track2->Pt() > 4 &&
+ //(TMath::Abs(track1->GetSnp()-track2->GetSnp())-2.) < scaleF * TMath::Sqrt(track1->GetSigmaSnp2()+track2->GetSigmaSnp2()) &&
+ //TMath::Abs(track1->GetTgl()-track2->GetTgl()) < scaleF * TMath::Sqrt(track1->GetSigmaTgl2()+track2->GetSigmaTgl2()) &&
+ //TMath::Abs(track1->OneOverPt()-track2->OneOverPt()) < scaleF * TMath::Sqrt(track1->GetSigma1Pt2()+track2->GetSigma1Pt2()) &&
+ (track1->Charge()+track2->Charge()) == 0 &&
+ track1->Eta()*track2->Eta()<0.0 && TMath::Abs(track1->Eta()+track2->Eta())<0.03 &&
+ TMath::Abs(TMath::Abs(track1->Phi()-track2->Phi())-TMath::Pi())<0.1
+ )
+ {
+ printf("COSMIC candidate \n");
+
+ printf("track1->Pt() %f, track1->Theta() %f, track1->Eta() %f, track1->Phi() %f, track1->Charge() %d \n", track1->Pt(), track1->Theta(), track1->Eta(), track1->Phi(), track1->Charge());
+ printf("track2->Pt() %f, track2->Theta() %f, track2->Eta() %f, track2->Phi() %f, track2->Charge() %d \n", track2->Pt(), track2->Theta(), track2->Eta(), track2->Phi(), track2->Charge());
+ printf("dtheta %f, deta %f, dphi %f, dq %d \n", track1->Theta()-track2->Theta(), track1->Eta()-track2->Eta(), track1->Phi()-track2->Phi(), track1->Charge()+track2->Charge());
+ printf("dsphi %f, errsphi %f, dtanl %f, errtanl %f \n", TMath::Abs(track1->GetSnp()-track2->GetSnp()), TMath::Sqrt(track1->GetSigmaSnp2()+track2->GetSigmaSnp2()), TMath::Abs(track1->GetTgl()-track2->GetTgl()), TMath::Sqrt(track1->GetSigmaTgl2()+track2->GetSigmaTgl2()));
+ return kTRUE;
+ }
+
+return kFALSE;
+}
+
+//____________________________________________________________________
+void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger)
{
//
// Prints the given configuration
case kTPC : str += "TPC-only"; break;
case kTPCITS : str += "Global tracking"; break;
case kTPCSPDvtx : str += "TPC tracking + SPD event vertex"; break;
+ case kTPCSPDvtxUpdate : str += "TPC tracks updated with SPD event vertex point"; break;
+ case kTPCITSHybrid : str += "TPC tracking + ITS refit + >1 SPD cluster"; break;
case kMCRec : str += "TPC tracking + Replace rec. with MC values"; break;
- case kMCPion : str += "TPC tracking + only pion MC tracks"; break;
- case kMCKaon : str += "TPC tracking + only kaon MC tracks"; break;
- case kMCProton : str += "TPC tracking + only proton MC tracks"; break;
- case kPlus: str += "TPC tracking + only positive charged tracks"; break;
- case kMinus : str += "TPC tracking + only negative charge tracks"; break;
}
str += " and trigger ";
- switch (trigger)
- {
- case AliPWG0Helper::kAcceptAll : str += "kAcceptAll"; break;
- case AliPWG0Helper::kMB1 : str += "MB1"; break;
- case AliPWG0Helper::kMB2 : str += "MB2"; break;
- case AliPWG0Helper::kMB3 : str += "MB3"; break;
- case AliPWG0Helper::kSPDGFO : str += "SPDGFO"; break;
- case AliPWG0Helper::kV0A : str += "V0A"; break;
- case AliPWG0Helper::kV0C : str += "V0C"; break;
- case AliPWG0Helper::kZDC : str += "ZDC"; break;
- case AliPWG0Helper::kZDCA : str += "ZDCA"; break;
- case AliPWG0Helper::kZDCC : str += "ZDCC"; break;
- case AliPWG0Helper::kFMDA : str += "FMDA"; break;
- case AliPWG0Helper::kFMDC : str += "FMDC"; break;
- case AliPWG0Helper::kFPANY : str += "FPANY"; break;
- case AliPWG0Helper::kStartOfFlags : str += "StartOfFlags"; break;
- case AliPWG0Helper::kOfflineFlag : str += "kOfflineFlag"; break;
- }
+ str += AliTriggerAnalysis::GetTriggerName(trigger);
str += " <<<<";
}
//_____________________________________________________________________________
-TH1F* AlidNdPtHelper::CreateResHisto(TH2F* hRes2, TH1F **phMean, Int_t integ, Bool_t drawBinFits, Int_t minHistEntries)
+TH1F* AlidNdPtHelper::CreateResHisto(TH2F* const hRes2, TH1F **phMean, Int_t integ, Bool_t drawBinFits, Int_t minHistEntries)
{
//
// Create mean and resolution
AliESDtrack *track=0;
for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
{
- if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
- analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon ||
- analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) {
-
- // track must be deleted by the user
+ if(analysisMode == AlidNdPtHelper::kTPC) {
+ //
+ // track must be deleted by user
+ // esd track parameters are replaced by TPCinner
+ //
track = AliESDtrackCuts::GetTPCOnlyTrack(esdEvent,iTrack);
- } else {
- track=esdEvent->GetTrack(iTrack);
+ if(!track) continue;
+ }
+ else if (analysisMode == AlidNdPtHelper::kTPCSPDvtx || analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate)
+ {
+ //
+ // track must be deleted by the user
+ // esd track parameters are replaced by TPCinner
+ //
+ track = AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(esdEvent,iTrack,kFALSE);
+ if(!track) continue;
+ }
+ else if( analysisMode == AlidNdPtHelper::kTPCITSHybrid )
+ {
+ track = AlidNdPtHelper::GetTrackSPDvtx(esdEvent,iTrack,kFALSE);
}
+ else
+ {
+ track = esdEvent->GetTrack(iTrack);
+ }
+
if(!track) continue;
if(track->Charge()==0) {
- if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
- analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon ||
- analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) {
-
+ if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
+ analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate)
+ {
delete track; continue;
} else {
continue;
}
if(analysisMode == AlidNdPtHelper::kTPC || analysisMode == AlidNdPtHelper::kTPCSPDvtx ||
- analysisMode == AlidNdPtHelper::kMCRec || analysisMode == kMCPion || analysisMode == kMCKaon ||
- analysisMode == kMCProton || analysisMode ==kPlus || analysisMode ==kMinus) {
+ analysisMode == AlidNdPtHelper::kTPCSPDvtxUpdate) {
allTracks->SetOwner(kTRUE);
}
}
//_____________________________________________________________________________
-Int_t AlidNdPtHelper::GetTPCMBTrackMult(AliESDEvent *esdEvent, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
+AliESDtrack *AlidNdPtHelper::GetTPCOnlyTrackSPDvtx(AliESDEvent* esdEvent, Int_t iTrack, Bool_t bUpdate)
+{
+//
+// Create ESD tracks from TPCinner parameters.
+// Propagte to DCA to SPD vertex.
+// Update using SPD vertex point (parameter)
+//
+// It is user responsibility to delete these tracks
+//
+
+ if (!esdEvent) return NULL;
+ if (!esdEvent->GetPrimaryVertexSPD() ) { return NULL; }
+ if (!esdEvent->GetPrimaryVertexSPD()->GetStatus() ) { return NULL; }
+
+ //
+ AliESDtrack* track = esdEvent->GetTrack(iTrack);
+ if (!track)
+ return NULL;
+
+ Bool_t isOK = kFALSE;
+ Double_t x[3]; track->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+
+ // create new ESD track
+ AliESDtrack *tpcTrack = new AliESDtrack();
+
+ // relate TPC-only tracks (TPCinner) to SPD vertex
+ AliExternalTrackParam cParam;
+ if(bUpdate) {
+ isOK = track->RelateToVertexTPCBxByBz(esdEvent->GetPrimaryVertexSPD(),b,kVeryBig,&cParam);
+ track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());
+
+ // reject fake tracks
+ if(track->Pt() > 10000.) {
+ ::Error("Exclude no physical tracks","pt>10000. GeV");
+ delete tpcTrack;
+ return NULL;
+ }
+ }
+ else {
+ isOK = track->RelateToVertexTPCBxByBz(esdEvent->GetPrimaryVertexSPD(), b, kVeryBig);
+ }
+
+ // only true if we have a tpc track
+ if (!track->FillTPCOnlyTrack(*tpcTrack))
+ {
+ delete tpcTrack;
+ return NULL;
+ }
+
+ if(!isOK) return NULL;
+
+return tpcTrack;
+}
+
+//_____________________________________________________________________________
+AliESDtrack *AlidNdPtHelper::GetTrackSPDvtx(AliESDEvent* esdEvent, Int_t iTrack, Bool_t bUpdate)
+{
+//
+// Propagte track to DCA to SPD vertex.
+// Update using SPD vertex point (parameter)
+//
+ if (!esdEvent) return NULL;
+ if (!esdEvent->GetPrimaryVertexSPD() ) { return NULL; }
+ if (!esdEvent->GetPrimaryVertexSPD()->GetStatus() ) { return NULL; }
+
+ //
+ AliESDtrack* track = esdEvent->GetTrack(iTrack);
+ if (!track)
+ return NULL;
+
+ Bool_t isOK = kFALSE;
+ Double_t x[3]; track->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+
+ // relate tracks to SPD vertex
+ AliExternalTrackParam cParam;
+ if(bUpdate) {
+ isOK = track->RelateToVertexBxByBz(esdEvent->GetPrimaryVertexSPD(),b,kVeryBig,&cParam);
+ track->Set(cParam.GetX(),cParam.GetAlpha(),cParam.GetParameter(),cParam.GetCovariance());
+
+ // reject fake tracks
+ if(track->Pt() > 10000.) {
+ ::Error("Exclude no physical tracks","pt>10000. GeV");
+ return NULL;
+ }
+ }
+ else {
+ isOK = track->RelateToVertexBxByBz(esdEvent->GetPrimaryVertexSPD(), b, kVeryBig);
+ }
+
+ if(!isOK) return NULL;
+
+return track;
+}
+
+//_____________________________________________________________________________
+Int_t AlidNdPtHelper::GetTPCMBTrackMult(AliESDEvent *const esdEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts)
{
//
// get MB event track multiplicity
if (!t->GetTPCInnerParam()) continue;
if (t->GetTPCNcls()<minTPCClust) continue;
//
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ const Double_t kMaxStep = 1; //max step over the material
+
AliExternalTrackParam *tpcTrack = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
- if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov))
+ if (!tpcTrack->PropagateToDCABxByBz(&vtx0,b,kMaxStep,dca,cov))
{
if(tpcTrack) delete tpcTrack;
continue;
}
//_____________________________________________________________________________
-Int_t AlidNdPtHelper::GetTPCMBPrimTrackMult(AliESDEvent *esdEvent, AliStack * stack, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts)
+Int_t AlidNdPtHelper::GetTPCMBPrimTrackMult(AliESDEvent *const esdEvent, AliStack *const stack, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts)
{
//
// get MB primary event track multiplicity
if (!t->GetTPCInnerParam()) continue;
if (t->GetTPCNcls()<minTPCClust) continue;
//
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ const Double_t kMaxStep = 1; //max step over the material
+
AliExternalTrackParam *tpcTrack = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
- if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov))
+ if (!tpcTrack->PropagateToDCABxByBz(&vtx0,b,kMaxStep,dca,cov))
{
if(tpcTrack) delete tpcTrack;
continue;
//_____________________________________________________________________________
-Int_t AlidNdPtHelper::GetMCTrueTrackMult(AliMCEvent *mcEvent, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts)
+Int_t AlidNdPtHelper::GetMCTrueTrackMult(AliMCEvent *const mcEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts)
{
//
// calculate mc event true track multiplicity
// only charged particles
Double_t charge = particle->GetPDG()->Charge()/3.;
- if (charge == 0.0)
+ if (TMath::Abs(charge) < 0.001)
continue;
// physical primary
Bool_t prim = stack->IsPhysicalPrimary(iMc);
if(!prim) continue;
- // checked accepted
- if(accCuts->AcceptTrack(particle))
+ // checked accepted without pt cut
+ //if(accCuts->AcceptTrack(particle))
+ if( particle->Eta() > accCuts->GetMinEta() && particle->Eta() < accCuts->GetMaxEta() )
{
mult++;
}
}
//_______________________________________________________________________
-void AlidNdPtHelper::PrintMCInfo(AliStack *pStack,Int_t label)
+void AlidNdPtHelper::PrintMCInfo(AliStack *const pStack,Int_t label)
{
// print information about particles in the stack
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::GetContCorrHisto(TH1 *hist)
+TH1* AlidNdPtHelper::GetContCorrHisto(TH1 *const hist)
{
//
// get contamination histogram
if(!hist) return 0;
Int_t nbins = hist->GetNbinsX();
- TH1 *h_cont = (TH1D *)hist->Clone();
+ TH1 *hCont = (TH1D *)hist->Clone();
for(Int_t i=0; i<=nbins+1; i++) {
Double_t binContent = hist->GetBinContent(i);
Double_t binError = hist->GetBinError(i);
- h_cont->SetBinContent(i,1.-binContent);
- h_cont->SetBinError(i,binError);
+ hCont->SetBinContent(i,1.-binContent);
+ hCont->SetBinError(i,binError);
}
-return h_cont;
+return hCont;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::ScaleByBinWidth(TH1 *hist)
+TH1* AlidNdPtHelper::ScaleByBinWidth(TH1 *const hist)
{
//
// scale by bin width
//
if(!hist) return 0;
- TH1 *h_scale = (TH1D *)hist->Clone();
- h_scale->Scale(1.,"width");
+ TH1 *hScale = (TH1D *)hist->Clone();
+ hScale->Scale(1.,"width");
-return h_scale;
+return hScale;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::CalcRelativeDifference(TH1 *hist1, TH1 *hist2)
+TH1* AlidNdPtHelper::CalcRelativeDifference(TH1 *const hist1, TH1 *const hist2)
{
//
// calculate rel. difference
if(!hist1) return 0;
if(!hist2) return 0;
- TH1 *h1_clone = (TH1D *)hist1->Clone();
- h1_clone->Sumw2();
+ TH1 *h1Clone = (TH1D *)hist1->Clone();
+ h1Clone->Sumw2();
// (rec-mc)/mc
- h1_clone->Add(hist2,-1);
- h1_clone->Divide(hist2);
+ h1Clone->Add(hist2,-1);
+ h1Clone->Divide(hist2);
-return h1_clone;
+return h1Clone;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::CalcRelativeDifferenceFun(TH1 *hist1, TF1 *fun)
+TH1* AlidNdPtHelper::CalcRelativeDifferenceFun(TH1 *const hist1, TF1 *const fun)
{
//
// calculate rel. difference
if(!hist1) return 0;
if(!fun) return 0;
- TH1 *h1_clone = (TH1D *)hist1->Clone();
- h1_clone->Sumw2();
+ TH1 *h1Clone = (TH1D *)hist1->Clone();
+ h1Clone->Sumw2();
//
- h1_clone->Add(fun,-1);
- h1_clone->Divide(hist1);
+ h1Clone->Add(fun,-1);
+ h1Clone->Divide(hist1);
-return h1_clone;
+return h1Clone;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::NormalizeToEvent(TH2 *hist1, TH1 *hist2)
+TH1* AlidNdPtHelper::NormalizeToEvent(TH2 *const hist1, TH1 *const hist2)
{
// normalise to event for a given multiplicity bin
// return pt histogram
Int_t nbinsX = hist1->GetNbinsX();
//Int_t nbinsY = hist1->GetNbinsY();
- TH1D *hist_norm = 0;
+ TH1D *histNorm = 0;
for(Int_t i=0; i<=nbinsX+1; i++) {
sprintf(name,"mom_%d",i);
TH1D *hist = (TH1D*)hist1->ProjectionY(name,i+1,i+1);
sprintf(name,"mom_norm");
if(i==0) {
- hist_norm = (TH1D *)hist->Clone(name);
- hist_norm->Reset();
+ histNorm = (TH1D *)hist->Clone(name);
+ histNorm->Reset();
}
Double_t nbEvents = hist2->GetBinContent(i);
if(!nbEvents) { nbEvents = 1.; };
hist->Scale(1./nbEvents);
- hist_norm->Add(hist);
+ histNorm->Add(hist);
}
-return hist_norm;
+return histNorm;
}
//_____________________________________________________________________________
-THnSparse* AlidNdPtHelper::GenerateCorrMatrix(THnSparse *hist1, THnSparse *hist2, char *name) {
+THnSparse* AlidNdPtHelper::GenerateCorrMatrix(THnSparse *const hist1, THnSparse *const hist2, char *const name) {
// generate correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-TH2* AlidNdPtHelper::GenerateCorrMatrix(TH2 *hist1, TH2 *hist2, char *name) {
+TH2* AlidNdPtHelper::GenerateCorrMatrix(TH2 *const hist1, TH2 *const hist2, char *const name) {
// generate correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::GenerateCorrMatrix(TH1 *hist1, TH1 *hist2, char *name) {
+TH1* AlidNdPtHelper::GenerateCorrMatrix(TH1 *const hist1, TH1 *const hist2, char *const name) {
// generate correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-THnSparse* AlidNdPtHelper::GenerateContCorrMatrix(THnSparse *hist1, THnSparse *hist2, char *name) {
+THnSparse* AlidNdPtHelper::GenerateContCorrMatrix(THnSparse *const hist1, THnSparse *const hist2, char *const name) {
// generate contamination correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-TH2* AlidNdPtHelper::GenerateContCorrMatrix(TH2 *hist1, TH2 *hist2, char *name) {
+TH2* AlidNdPtHelper::GenerateContCorrMatrix(TH2 *const hist1, TH2 *const hist2, char *const name) {
// generate contamination correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-TH1* AlidNdPtHelper::GenerateContCorrMatrix(TH1 *hist1, TH1 *hist2, char *name) {
+TH1* AlidNdPtHelper::GenerateContCorrMatrix(TH1 *const hist1, TH1 *const hist2, char *const name) {
// generate contamination correction matrix
if(!hist1 || !hist2) return 0;
}
//_____________________________________________________________________________
-const AliESDVertex* AlidNdPtHelper::GetTPCVertexZ(AliESDEvent* esdEvent, AlidNdPtEventCuts *evtCuts, AlidNdPtAcceptanceCuts *accCuts, AliESDtrackCuts *trackCuts, Float_t fraction, Int_t ntracksMin){
+const AliESDVertex* AlidNdPtHelper::GetTPCVertexZ(AliESDEvent* const esdEvent, AlidNdPtEventCuts *const evtCuts, AlidNdPtAcceptanceCuts *const accCuts, AliESDtrackCuts *const trackCuts, Float_t fraction, Int_t ntracksMin){
//
// TPC Z vertexer
//
if (!t->GetTPCInnerParam()) continue;
if (t->GetTPCNcls()<minTPCClust) continue;
//
+
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ const Double_t kMaxStep = 1; //max step over the material
+
AliExternalTrackParam *tpcTrack = new AliExternalTrackParam(*(t->GetTPCInnerParam()));
- if (!tpcTrack->PropagateToDCA(&vtx0,esdEvent->GetMagneticField(),100.,dca,cov)) continue;
+ if (!tpcTrack->PropagateToDCABxByBz(&vtx0,b,kMaxStep,dca,cov)) continue;
//
if (TMath::Abs(dca[0])>maxDCAr) continue;
}
//_____________________________________________________________________________
-Int_t AlidNdPtHelper::GetSPDMBTrackMult(AliESDEvent* esdEvent, Float_t deltaThetaCut, Float_t deltaPhiCut)
+Int_t AlidNdPtHelper::GetSPDMBTrackMult(AliESDEvent* const esdEvent, Float_t deltaThetaCut, Float_t deltaPhiCut)
{
//
// SPD track multiplicity
}
//_____________________________________________________________________________
-Int_t AlidNdPtHelper::GetSPDMBPrimTrackMult(AliESDEvent* esdEvent, AliStack* stack, Float_t deltaThetaCut, Float_t deltaPhiCut)
+Int_t AlidNdPtHelper::GetSPDMBPrimTrackMult(AliESDEvent* const esdEvent, AliStack* const stack, Float_t deltaThetaCut, Float_t deltaPhiCut)
{
//
// SPD track multiplicity
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff