#include "AliAODTrack.h"
#include "TList.h"
+#include "TCanvas.h"
#include "TH2F.h"
#include "TH1F.h"
#include "TH3F.h"
const Int_t AliUEHistograms::fgkUEHists = 3;
-AliUEHistograms::AliUEHistograms(const char* name, const char* histograms) :
+AliUEHistograms::AliUEHistograms(const char* name, const char* histograms, const char* binning) :
TNamed(name, name),
fNumberDensitypT(0),
fSumpT(0),
fCorrelationR(0),
fCorrelationLeading2Phi(0),
fCorrelationMultiplicity(0),
+ fYields(0),
+ fInvYield2(0),
fEventCount(0),
fEventCountDifferential(0),
fVertexContributors(0),
fCentralityDistribution(0),
fCentralityCorrelation(0),
fITSClusterMap(0),
+ fControlConvResoncances(0),
+ fEfficiencyCorrectionTriggers(0),
+ fEfficiencyCorrectionAssociated(0),
fSelectCharge(0),
+ fTriggerSelectCharge(0),
+ fAssociatedSelectCharge(0),
fTriggerRestrictEta(-1),
fEtaOrdering(kFALSE),
fCutConversions(kFALSE),
fCutResonances(kFALSE),
- fRunNumber(0)
+ fRejectResonanceDaughters(-1),
+ fOnlyOneEtaSide(0),
+ fWeightPerEvent(kFALSE),
+ fPtOrder(kTRUE),
+ fTwoTrackCutMinRadius(0.8),
+ fRunNumber(0),
+ fMergeCount(1)
{
// Constructor
//
// 3 = NumberDensityPhi
// 4 = NumberDensityPhiCentrality (other multiplicity for Pb)
+ AliLog::SetClassDebugLevel("AliCFContainer", -1);
+ AliLog::SetClassDebugLevel("AliCFGridSparse", -3);
+
fTwoTrackDistancePt[0] = 0;
fTwoTrackDistancePt[1] = 0;
TString histogramsStr(histograms);
+ TString defaultBinningStr;
+ defaultBinningStr = "eta: -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0\n"
+ "p_t_assoc: 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 8.0\n"
+ "p_t_leading: 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5, 16.0, 16.5, 17.0, 17.5, 18.0, 18.5, 19.0, 19.5, 20.0, 20.5, 21.0, 21.5, 22.0, 22.5, 23.0, 23.5, 24.0, 24.5, 25.0, 25.5, 26.0, 26.5, 27.0, 27.5, 28.0, 28.5, 29.0, 29.5, 30.0, 30.5, 31.0, 31.5, 32.0, 32.5, 33.0, 33.5, 34.0, 34.5, 35.0, 35.5, 36.0, 36.5, 37.0, 37.5, 38.0, 38.5, 39.0, 39.5, 40.0, 40.5, 41.0, 41.5, 42.0, 42.5, 43.0, 43.5, 44.0, 44.5, 45.0, 45.5, 46.0, 46.5, 47.0, 47.5, 48.0, 48.5, 49.0, 49.5, 50.0\n"
+ "p_t_leading_course: 0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0\n"
+ "p_t_eff: 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.5, 5.0, 6.0, 7.0, 8.0\n"
+ "vertex_eff: -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10\n"
+ ;
+
+ if (histogramsStr.Contains("4") || histogramsStr.Contains("5") || histogramsStr.Contains("6")) // Dphi Corr
+ {
+ if (histogramsStr.Contains("C"))
+ defaultBinningStr += "multiplicity: 0, 20, 40, 60, 80, 100.1\n"; // course
+ else
+ defaultBinningStr += "multiplicity: 0, 1, 2, 3, 4, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100.1\n";
+
+ if (histogramsStr.Contains("5"))
+ defaultBinningStr += "vertex: -7, -5, -3, -1, 1, 3, 5, 7\n";
+ else
+ defaultBinningStr += "vertex: -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10\n";
+
+ if (histogramsStr.Contains("R"))
+ defaultBinningStr += "delta_phi: -1.570796, -1.483530, -1.396263, -1.308997, -1.221730, -1.134464, -1.047198, -0.959931, -0.872665, -0.785398, -0.698132, -0.610865, -0.523599, -0.436332, -0.349066, -0.261799, -0.174533, -0.087266, 0.0, 0.087266, 0.174533, 0.261799, 0.349066, 0.436332, 0.523599, 0.610865, 0.698132, 0.785398, 0.872665, 0.959931, 1.047198, 1.134464, 1.221730, 1.308997, 1.396263, 1.483530, 1.570796, 1.658063, 1.745329, 1.832596, 1.919862, 2.007129, 2.094395, 2.181662, 2.268928, 2.356194, 2.443461, 2.530727, 2.617994, 2.705260, 2.792527, 2.879793, 2.967060, 3.054326, 3.141593, 3.228859, 3.316126, 3.403392, 3.490659, 3.577925, 3.665191, 3.752458, 3.839724, 3.926991, 4.014257, 4.101524, 4.188790, 4.276057, 4.363323, 4.450590, 4.537856, 4.625123, 4.712389\n" // this binning starts at -pi/2 and is modulo 3
+ "delta_eta: -2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0,2.1, 2.2, 2.3, 2.4\n"
+ ;
+ else // for TTR studies
+ defaultBinningStr += "delta_phi: -1.570796, -1.483530, -1.396263, -1.308997, -1.221730, -1.134464, -1.047198, -0.959931, -0.872665, -0.785398, -0.698132, -0.610865, -0.523599, -0.436332, -0.349066, -0.261799, -0.174533, -0.087266, -0.043633, -0.021817, 0.0, 0.021817, 0.043633, 0.087266, 0.174533, 0.261799, 0.349066, 0.436332, 0.523599, 0.610865, 0.698132, 0.785398, 0.872665, 0.959931, 1.047198, 1.134464, 1.221730, 1.308997, 1.396263, 1.483530, 1.570796, 1.658063, 1.745329, 1.832596, 1.919862, 2.007129, 2.094395, 2.181662, 2.268928, 2.356194, 2.443461, 2.530727, 2.617994, 2.705260, 2.792527, 2.879793, 2.967060, 3.054326, 3.141593, 3.228859, 3.316126, 3.403392, 3.490659, 3.577925, 3.665191, 3.752458, 3.839724, 3.926991, 4.014257, 4.101524, 4.188790, 4.276057, 4.363323, 4.450590, 4.537856, 4.625123, 4.712389\n"
+ "delta_eta: -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.05, -0.025, 0, 0.025, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0\n"
+ ;
+ }
+ else // UE
+ defaultBinningStr += "multiplicity: -0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5, 13.5, 200.0\n"
+ "delta_phi: -1.570796, -1.483530, -1.396263, -1.308997, -1.221730, -1.134464, -1.047198, -0.959931, -0.872665, -0.785398, -0.698132, -0.610865, -0.523599, -0.436332, -0.349066, -0.261799, -0.174533, -0.087266, 0.0, 0.087266, 0.174533, 0.261799, 0.349066, 0.436332, 0.523599, 0.610865, 0.698132, 0.785398, 0.872665, 0.959931, 1.047198, 1.134464, 1.221730, 1.308997, 1.396263, 1.483530, 1.570796, 1.658063, 1.745329, 1.832596, 1.919862, 2.007129, 2.094395, 2.181662, 2.268928, 2.356194, 2.443461, 2.530727, 2.617994, 2.705260, 2.792527, 2.879793, 2.967060, 3.054326, 3.141593, 3.228859, 3.316126, 3.403392, 3.490659, 3.577925, 3.665191, 3.752458, 3.839724, 3.926991, 4.014257, 4.101524, 4.188790, 4.276057, 4.363323, 4.450590, 4.537856, 4.625123, 4.712389\n"
+ "vertex: -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10\n"
+ ;
+
+ // combine customBinning with defaultBinningStr -> use customBinning where available and otherwise defaultBinningStr
+ TString binningStr = AliUEHist::CombineBinning(defaultBinningStr, TString(binning));
+
if (histogramsStr.Contains("1"))
- fNumberDensitypT = new AliUEHist("NumberDensitypT");
+ fNumberDensitypT = new AliUEHist("NumberDensitypT", binningStr);
if (histogramsStr.Contains("2"))
- fSumpT = new AliUEHist("SumpT");
+ fSumpT = new AliUEHist("SumpT", binningStr);
if (histogramsStr.Contains("3"))
- fNumberDensityPhi = new AliUEHist("NumberDensityPhi");
+ fNumberDensityPhi = new AliUEHist("NumberDensityPhi", binningStr);
else if (histogramsStr.Contains("4"))
- fNumberDensityPhi = new AliUEHist("NumberDensityPhiCentrality");
- else if (histogramsStr.Contains("5"))
- fNumberDensityPhi = new AliUEHist("NumberDensityPhiCentralityVtx");
+ fNumberDensityPhi = new AliUEHist("NumberDensityPhiCentrality", binningStr);
+ else if (histogramsStr.Contains("5") || histogramsStr.Contains("6"))
+ fNumberDensityPhi = new AliUEHist("NumberDensityPhiCentralityVtx", binningStr);
// do not add this hists to the directory
Bool_t oldStatus = TH1::AddDirectoryStatus();
TH1::AddDirectory(kFALSE);
- if (!histogramsStr.Contains("4") && !histogramsStr.Contains("5"))
+ if (!histogramsStr.Contains("4") && !histogramsStr.Contains("5") && !histogramsStr.Contains("6"))
{
fCorrelationpT = new TH2F("fCorrelationpT", ";p_{T,lead} (MC);p_{T,lead} (RECO)", 200, 0, 50, 200, 0, 50);
fCorrelationEta = new TH2F("fCorrelationEta", ";#eta_{lead} (MC);#eta_{T,lead} (RECO)", 200, -1, 1, 200, -1, 1);
else
{
fCorrelationpT = new TH2F("fCorrelationpT", ";Centrality;p_{T} (RECO)", 100, 0, 100.001, 200, 0, 50);
- fCorrelationEta = new TH2F("fCorrelationEta", ";Centrality;#eta (RECO)", 100, 0, 100.001, 200, -1, 1);
+ fCorrelationEta = new TH2F("fCorrelationEta", ";Centrality;#eta (RECO)", 100, 0, 100.001, 200, -5, 5);
fCorrelationPhi = new TH2F("fCorrelationPhi", ";Centrality;#varphi (RECO)", 100, 0, 100.001, 200, 0, TMath::TwoPi());
}
fCorrelationR = new TH2F("fCorrelationR", ";R;p_{T,lead} (MC)", 200, 0, 2, 200, 0, 50);
fCorrelationLeading2Phi = new TH2F("fCorrelationLeading2Phi", ";#Delta #varphi;p_{T,lead} (MC)", 200, -TMath::Pi(), TMath::Pi(), 200, 0, 50);
fCorrelationMultiplicity = new TH2F("fCorrelationMultiplicity", ";MC tracks;Reco tracks", 100, -0.5, 99.5, 100, -0.5, 99.5);
-
- if (!histogramsStr.Contains("4") && !histogramsStr.Contains("5"))
+ fYields = new TH3F("fYields", ";centrality;pT;eta", 100, 0, 100, 40, 0, 20, 100, -1, 1);
+ fInvYield2 = new TH2F("fInvYield2", ";centrality;pT;1/pT dNch/dpT", 100, 0, 100, 80, 0, 20);
+
+ if (!histogramsStr.Contains("4") && !histogramsStr.Contains("5") && !histogramsStr.Contains("6"))
{
fEventCount = new TH2F("fEventCount", ";step;event type;count", AliUEHist::fgkCFSteps+2, -2.5, -0.5 + AliUEHist::fgkCFSteps, 3, -0.5, 2.5);
fEventCount->GetYaxis()->SetBinLabel(1, "ND");
if (fNumberDensityPhi)
{
fCentralityDistribution = new TH1F("fCentralityDistribution", ";centrality;count", fNumberDensityPhi->GetEventHist()->GetNBins(1), fNumberDensityPhi->GetEventHist()->GetAxis(1, 0)->GetXbins()->GetArray());
- fCentralityCorrelation = new TH2F("fCentralityCorrelation", ";centrality;multiplicity", fNumberDensityPhi->GetEventHist()->GetNBins(1), fNumberDensityPhi->GetEventHist()->GetAxis(1, 0)->GetXbins()->GetArray(), 200, 0, 4000);
+ fCentralityCorrelation = new TH2F("fCentralityCorrelation", ";centrality;multiplicity", 404, 0, 101, 200, 0, 4000);
}
fITSClusterMap = new TH3F("fITSClusterMap", "; its cluster map; centrality; pT", 256, -0.5, 255.5, 20, 0, 100.001, 100, 0, 20);
+ fControlConvResoncances = new TH2F("fControlConvResoncances", ";id;delta mass", 3, -0.5, 2.5, 100, -0.1, 0.1);
+
TH1::AddDirectory(oldStatus);
}
fCorrelationR(0),
fCorrelationLeading2Phi(0),
fCorrelationMultiplicity(0),
+ fYields(0),
+ fInvYield2(0),
fEventCount(0),
fEventCountDifferential(0),
fVertexContributors(0),
fCentralityDistribution(0),
fCentralityCorrelation(0),
fITSClusterMap(0),
+ fControlConvResoncances(0),
+ fEfficiencyCorrectionTriggers(0),
+ fEfficiencyCorrectionAssociated(0),
fSelectCharge(0),
+ fTriggerSelectCharge(0),
+ fAssociatedSelectCharge(0),
fTriggerRestrictEta(-1),
fEtaOrdering(kFALSE),
fCutConversions(kFALSE),
fCutResonances(kFALSE),
- fRunNumber(0)
+ fRejectResonanceDaughters(-1),
+ fOnlyOneEtaSide(0),
+ fWeightPerEvent(kFALSE),
+ fPtOrder(kTRUE),
+ fTwoTrackCutMinRadius(0.8),
+ fRunNumber(0),
+ fMergeCount(1)
{
//
// AliUEHistograms copy constructor
fCorrelationMultiplicity = 0;
}
+ if (fYields)
+ {
+ delete fYields;
+ fYields = 0;
+ }
+
+ if (fInvYield2)
+ {
+ delete fInvYield2;
+ fInvYield2 = 0;
+ }
+
if (fEventCount)
{
delete fEventCount;
delete fITSClusterMap;
fITSClusterMap = 0;
}
-
+
for (Int_t i=0; i<2; i++)
if (fTwoTrackDistancePt[i])
{
delete fTwoTrackDistancePt[i];
fTwoTrackDistancePt[i] = 0;
}
+
+ if (fControlConvResoncances)
+ {
+ delete fControlConvResoncances;
+ fControlConvResoncances = 0;
+ }
+
+ if (fEfficiencyCorrectionTriggers)
+ {
+ delete fEfficiencyCorrectionTriggers;
+ fEfficiencyCorrectionTriggers = 0;
+ }
+
+ if (fEfficiencyCorrectionAssociated)
+ {
+ delete fEfficiencyCorrectionAssociated;
+ fEfficiencyCorrectionAssociated = 0;
+ }
}
AliUEHist* AliUEHistograms::GetUEHist(Int_t id)
}
//____________________________________________________________________
-void AliUEHistograms::FillCorrelations(Double_t centrality, Float_t zVtx, AliUEHist::CFStep step, TObjArray* particles, TObjArray* mixed, Float_t weight, Bool_t firstTime, Bool_t twoTrackEfficiencyCut, Float_t bSign)
+void AliUEHistograms::FillCorrelations(Double_t centrality, Float_t zVtx, AliUEHist::CFStep step, TObjArray* particles, TObjArray* mixed, Float_t weight, Bool_t firstTime, Bool_t twoTrackEfficiencyCut, Float_t bSign, Float_t twoTrackEfficiencyCutValue, Bool_t applyEfficiency)
{
// fills the fNumberDensityPhi histogram
//
if (weight < 0)
fillpT = kTRUE;
+ if (twoTrackEfficiencyCut && !fTwoTrackDistancePt[0])
+ {
+ // do not add this hists to the directory
+ Bool_t oldStatus = TH1::AddDirectoryStatus();
+ TH1::AddDirectory(kFALSE);
+
+ fTwoTrackDistancePt[0] = new TH3F("fTwoTrackDistancePt[0]", ";#Delta#eta;#Delta#varphi^{*}_{min};#Delta p_{T}", 100, -0.15, 0.15, 100, -0.05, 0.05, 20, 0, 10);
+ fTwoTrackDistancePt[1] = (TH3F*) fTwoTrackDistancePt[0]->Clone("fTwoTrackDistancePt[1]");
+
+ TH1::AddDirectory(oldStatus);
+ }
+
// Eta() is extremely time consuming, therefore cache it for the inner loop here:
TObjArray* input = (mixed) ? mixed : particles;
TArrayF eta(input->GetEntriesFast());
for (Int_t i=0; i<input->GetEntriesFast(); i++)
- eta[i] = ((AliVParticle*) input->At(i))->Eta();
+ eta[i] = ((AliVParticle*) input->UncheckedAt(i))->Eta();
// if particles is not set, just fill event statistics
if (particles)
if (mixed)
jMax = mixed->GetEntriesFast();
+ TH1* triggerWeighting = 0;
+ if (fWeightPerEvent)
+ {
+ TAxis* axis = fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->GetGrid(0)->GetGrid()->GetAxis(2);
+ triggerWeighting = new TH1F("triggerWeighting", "", axis->GetNbins(), axis->GetXbins()->GetArray());
+
+ for (Int_t i=0; i<particles->GetEntriesFast(); i++)
+ {
+ AliVParticle* triggerParticle = (AliVParticle*) particles->UncheckedAt(i);
+
+ // some optimization
+ Float_t triggerEta = triggerParticle->Eta();
+
+ if (fTriggerRestrictEta > 0 && TMath::Abs(triggerEta) > fTriggerRestrictEta)
+ continue;
+
+ if (fOnlyOneEtaSide != 0)
+ {
+ if (fOnlyOneEtaSide * triggerEta < 0)
+ continue;
+ }
+
+ if (fTriggerSelectCharge != 0)
+ if (triggerParticle->Charge() * fTriggerSelectCharge < 0)
+ continue;
+
+ triggerWeighting->Fill(triggerParticle->Pt());
+ }
+ }
+
+ // identify K, Lambda candidates and flag those particles
+ // a TObject bit is used for this
+ const UInt_t kResonanceDaughterFlag = 1 << 14;
+ if (fRejectResonanceDaughters > 0)
+ {
+ Double_t resonanceMass = -1;
+ Double_t massDaughter1 = -1;
+ Double_t massDaughter2 = -1;
+ const Double_t interval = 0.02;
+
+ switch (fRejectResonanceDaughters)
+ {
+ case 1: resonanceMass = 1.2; massDaughter1 = 0.1396; massDaughter2 = 0.9383; break; // method test
+ case 2: resonanceMass = 0.4976; massDaughter1 = 0.1396; massDaughter2 = massDaughter1; break; // k0
+ case 3: resonanceMass = 1.115; massDaughter1 = 0.1396; massDaughter2 = 0.9383; break; // lambda
+ default: AliFatal(Form("Invalid setting %d", fRejectResonanceDaughters));
+ }
+
+ for (Int_t i=0; i<particles->GetEntriesFast(); i++)
+ particles->UncheckedAt(i)->ResetBit(kResonanceDaughterFlag);
+ if (mixed)
+ for (Int_t i=0; i<jMax; i++)
+ mixed->UncheckedAt(i)->ResetBit(kResonanceDaughterFlag);
+
+ for (Int_t i=0; i<particles->GetEntriesFast(); i++)
+ {
+ AliVParticle* triggerParticle = (AliVParticle*) particles->UncheckedAt(i);
+
+ for (Int_t j=0; j<jMax; j++)
+ {
+ if (!mixed && i == j)
+ continue;
+
+ AliVParticle* particle = 0;
+ if (!mixed)
+ particle = (AliVParticle*) particles->UncheckedAt(j);
+ else
+ particle = (AliVParticle*) mixed->UncheckedAt(j);
+
+ // check if both particles point to the same element (does not occur for mixed events, but if subsets are mixed within the same event)
+ if (mixed && triggerParticle->IsEqual(particle))
+ continue;
+
+ if (triggerParticle->Charge() * particle->Charge() > 0)
+ continue;
+
+ Float_t mass = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerParticle->Eta(), triggerParticle->Phi(), particle->Pt(), particle->Eta(), particle->Phi(), massDaughter1, massDaughter2);
+
+ if (TMath::Abs(mass - resonanceMass*resonanceMass) < interval*5)
+ {
+ mass = GetInvMassSquared(triggerParticle->Pt(), triggerParticle->Eta(), triggerParticle->Phi(), particle->Pt(), particle->Eta(), particle->Phi(), massDaughter1, massDaughter2);
+
+ if (mass > (resonanceMass-interval)*(resonanceMass-interval) && mass < (resonanceMass+interval)*(resonanceMass+interval))
+ {
+ triggerParticle->SetBit(kResonanceDaughterFlag);
+ particle->SetBit(kResonanceDaughterFlag);
+
+// Printf("Flagged %d %d %f", i, j, TMath::Sqrt(mass));
+ }
+ }
+ }
+ }
+ }
+
for (Int_t i=0; i<particles->GetEntriesFast(); i++)
{
- AliVParticle* triggerParticle = (AliVParticle*) particles->At(i);
+ AliVParticle* triggerParticle = (AliVParticle*) particles->UncheckedAt(i);
// some optimization
Float_t triggerEta = triggerParticle->Eta();
-
- if (!mixed)
- {
- // QA
- fCorrelationpT->Fill(centrality, triggerParticle->Pt());
- fCorrelationEta->Fill(centrality, triggerEta);
- fCorrelationPhi->Fill(centrality, triggerParticle->Phi());
-/* if (dynamic_cast<AliAODTrack*>(triggerParticle))
- fITSClusterMap->Fill(((AliAODTrack*) triggerParticle)->GetITSClusterMap(), centrality, triggerParticle->Pt());*/
- }
-
+
if (fTriggerRestrictEta > 0 && TMath::Abs(triggerEta) > fTriggerRestrictEta)
continue;
+
+ if (fOnlyOneEtaSide != 0)
+ {
+ if (fOnlyOneEtaSide * triggerEta < 0)
+ continue;
+ }
+ if (fTriggerSelectCharge != 0)
+ if (triggerParticle->Charge() * fTriggerSelectCharge < 0)
+ continue;
+
+ if (fRejectResonanceDaughters > 0)
+ if (triggerParticle->TestBit(kResonanceDaughterFlag))
+ {
+// Printf("Skipped i=%d", i);
+ continue;
+ }
+
for (Int_t j=0; j<jMax; j++)
{
if (!mixed && i == j)
AliVParticle* particle = 0;
if (!mixed)
- particle = (AliVParticle*) particles->At(j);
+ particle = (AliVParticle*) particles->UncheckedAt(j);
else
- particle = (AliVParticle*) mixed->At(j);
+ particle = (AliVParticle*) mixed->UncheckedAt(j);
- // check if both particles point to the same element (does not occur for mixed events, but if subsets are mixed within the same event for cross-checks)
- if (mixed && triggerParticle == particle)
+ // check if both particles point to the same element (does not occur for mixed events, but if subsets are mixed within the same event)
+ if (mixed && triggerParticle->IsEqual(particle))
continue;
- if (particle->Pt() > triggerParticle->Pt())
- continue;
-
+ if (fPtOrder)
+ if (particle->Pt() >= triggerParticle->Pt())
+ continue;
+
+ if (fAssociatedSelectCharge != 0)
+ if (particle->Charge() * fAssociatedSelectCharge < 0)
+ continue;
+
if (fSelectCharge > 0)
{
// skip like sign
continue;
}
- // conversions
+ if (fRejectResonanceDaughters > 0)
+ if (particle->TestBit(kResonanceDaughterFlag))
+ {
+// Printf("Skipped j=%d", j);
+ continue;
+ }
+
+ // conversions
if (fCutConversions && particle->Charge() * triggerParticle->Charge() < 0)
{
- Float_t mass = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.510e-3);
+ Float_t mass = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.510e-3, 0.510e-3);
+
+ if (mass < 0.1)
+ {
+ mass = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.510e-3, 0.510e-3);
+
+ fControlConvResoncances->Fill(0.0, mass);
- if (mass < 0.04*0.04)
- continue;
+ if (mass < 0.04*0.04)
+ continue;
+ }
}
- // K0s, rhos
+ // K0s
if (fCutResonances && particle->Charge() * triggerParticle->Charge() < 0)
{
- Float_t mass = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396);
+ Float_t mass = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.1396);
- if ((mass > 0.49*0.49 && mass < 0.51*0.51) || (mass > 0.765*0.765 && mass < 0.785*0.785))
- continue;
+ const Float_t kK0smass = 0.4976;
+
+ if (TMath::Abs(mass - kK0smass*kK0smass) < 0.1)
+ {
+ mass = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.1396);
+
+ fControlConvResoncances->Fill(1, mass - kK0smass*kK0smass);
+
+ if (mass > (kK0smass-0.02)*(kK0smass-0.02) && mass < (kK0smass+0.02)*(kK0smass+0.02))
+ continue;
+ }
}
+ // Lambda
+ if (fCutResonances && particle->Charge() * triggerParticle->Charge() < 0)
+ {
+ Float_t mass1 = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.9383);
+ Float_t mass2 = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.9383, 0.1396);
+
+ const Float_t kLambdaMass = 1.115;
+
+ if (TMath::Abs(mass1 - kLambdaMass*kLambdaMass) < 0.1)
+ {
+ mass1 = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.9383);
+
+ fControlConvResoncances->Fill(2, mass1 - kLambdaMass*kLambdaMass);
+
+ if (mass1 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass1 < (kLambdaMass+0.02)*(kLambdaMass+0.02))
+ continue;
+ }
+ if (TMath::Abs(mass2 - kLambdaMass*kLambdaMass) < 0.1)
+ {
+ mass2 = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.9383, 0.1396);
+
+ fControlConvResoncances->Fill(2, mass2 - kLambdaMass*kLambdaMass);
+
+ if (mass2 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass2 < (kLambdaMass+0.02)*(kLambdaMass+0.02))
+ continue;
+ }
+ }
+
if (twoTrackEfficiencyCut)
{
+ // the variables & cuthave been developed by the HBT group
+ // see e.g. https://indico.cern.ch/materialDisplay.py?contribId=36&sessionId=6&materialId=slides&confId=142700
+
Float_t phi1 = triggerParticle->Phi();
Float_t pt1 = triggerParticle->Pt();
Float_t charge1 = triggerParticle->Charge();
Float_t deta = triggerEta - eta[j];
// optimization
- if (TMath::Abs(deta) < 0.02)
+ if (TMath::Abs(deta) < twoTrackEfficiencyCutValue * 2.5 * 3)
{
- Float_t dphistarmin = 1e5;
- Float_t dphistarminabs = 1e5;
+ // check first boundaries to see if is worth to loop and find the minimum
+ Float_t dphistar1 = GetDPhiStar(phi1, pt1, charge1, phi2, pt2, charge2, fTwoTrackCutMinRadius, bSign);
+ Float_t dphistar2 = GetDPhiStar(phi1, pt1, charge1, phi2, pt2, charge2, 2.5, bSign);
+
+ const Float_t kLimit = twoTrackEfficiencyCutValue * 3;
- for (Double_t rad=0.8; rad<2.51; rad+=0.05)
+ Float_t dphistarminabs = 1e5;
+ Float_t dphistarmin = 1e5;
+ if (TMath::Abs(dphistar1) < kLimit || TMath::Abs(dphistar2) < kLimit || dphistar1 * dphistar2 < 0)
{
- Float_t dphistar = phi1 - phi2 - TMath::ASin(charge1 * 0.075 * bSign * rad / pt1) + TMath::ASin(charge2 * 0.075 * bSign * rad / pt2);
- Float_t dphistarabs = TMath::Abs(dphistar);
+ for (Double_t rad=fTwoTrackCutMinRadius; rad<2.51; rad+=0.01)
+ {
+ Float_t dphistar = GetDPhiStar(phi1, pt1, charge1, phi2, pt2, charge2, rad, bSign);
+
+ Float_t dphistarabs = TMath::Abs(dphistar);
+
+ if (dphistarabs < dphistarminabs)
+ {
+ dphistarmin = dphistar;
+ dphistarminabs = dphistarabs;
+ }
+ }
- if (dphistarabs < dphistarminabs)
+ fTwoTrackDistancePt[0]->Fill(deta, dphistarmin, TMath::Abs(pt1 - pt2));
+
+ if (dphistarminabs < twoTrackEfficiencyCutValue && TMath::Abs(deta) < twoTrackEfficiencyCutValue)
{
- dphistarmin = dphistar;
- dphistarminabs = dphistarabs;
+// Printf("Removed track pair %d %d with %f %f %f %f %f %f %f %f %f", i, j, deta, dphistarminabs, phi1, pt1, charge1, phi2, pt2, charge2, bSign);
+ continue;
}
+
+ fTwoTrackDistancePt[1]->Fill(deta, dphistarmin, TMath::Abs(pt1 - pt2));
}
-
- if (dphistarminabs < 0.02)
- continue;
}
}
if (fillpT)
weight = particle->Pt();
+
+ Double_t useWeight = weight;
+ if (applyEfficiency)
+ {
+ if (fEfficiencyCorrectionAssociated)
+ {
+ Int_t effVars[4];
+ // associated particle
+ effVars[0] = fEfficiencyCorrectionAssociated->GetAxis(0)->FindBin(eta[j]);
+ effVars[1] = fEfficiencyCorrectionAssociated->GetAxis(1)->FindBin(vars[1]); //pt
+ effVars[2] = fEfficiencyCorrectionAssociated->GetAxis(2)->FindBin(vars[3]); //centrality
+ effVars[3] = fEfficiencyCorrectionAssociated->GetAxis(3)->FindBin(vars[5]); //zVtx
+
+ // Printf("%d %d %d %d %f", effVars[0], effVars[1], effVars[2], effVars[3], fEfficiencyCorrectionAssociated->GetBinContent(effVars));
+
+ useWeight *= fEfficiencyCorrectionAssociated->GetBinContent(effVars);
+ }
+ if (fEfficiencyCorrectionTriggers)
+ {
+ Int_t effVars[4];
+
+ effVars[0] = fEfficiencyCorrectionTriggers->GetAxis(0)->FindBin(triggerEta);
+ effVars[1] = fEfficiencyCorrectionTriggers->GetAxis(1)->FindBin(vars[2]); //pt
+ effVars[2] = fEfficiencyCorrectionTriggers->GetAxis(2)->FindBin(vars[3]); //centrality
+ effVars[3] = fEfficiencyCorrectionTriggers->GetAxis(3)->FindBin(vars[5]); //zVtx
+ useWeight *= fEfficiencyCorrectionTriggers->GetBinContent(effVars);
+ }
+ }
+
+ if (fWeightPerEvent)
+ {
+ Int_t weightBin = triggerWeighting->GetXaxis()->FindBin(vars[2]);
+// Printf("Using weight %f", triggerWeighting->GetBinContent(weightBin));
+ useWeight /= triggerWeighting->GetBinContent(weightBin);
+ }
// fill all in toward region and do not use the other regions
- fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step, weight);
-
+ fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step, useWeight);
+
// Printf("%.2f %.2f --> %.2f", triggerEta, eta[j], vars[0]);
}
vars[0] = triggerParticle->Pt();
vars[1] = centrality;
vars[2] = zVtx;
- fNumberDensityPhi->GetEventHist()->Fill(vars, step);
+
+ Double_t useWeight = 1;
+ if (fEfficiencyCorrectionTriggers && applyEfficiency)
+ {
+ Int_t effVars[4];
+
+ // trigger particle
+ effVars[0] = fEfficiencyCorrectionTriggers->GetAxis(0)->FindBin(triggerEta);
+ effVars[1] = fEfficiencyCorrectionTriggers->GetAxis(1)->FindBin(vars[0]); //pt
+ effVars[2] = fEfficiencyCorrectionTriggers->GetAxis(2)->FindBin(vars[1]); //centrality
+ effVars[3] = fEfficiencyCorrectionTriggers->GetAxis(3)->FindBin(vars[2]); //zVtx
+ useWeight *= fEfficiencyCorrectionTriggers->GetBinContent(effVars);
+ }
+
+ if (TMath::Abs(triggerEta) < 0.8 && triggerParticle->Pt() > 0)
+ fInvYield2->Fill(centrality, triggerParticle->Pt(), useWeight / triggerParticle->Pt());
+
+ if (fWeightPerEvent)
+ {
+ // leads effectively to a filling of one entry per filled trigger particle pT bin
+ Int_t weightBin = triggerWeighting->GetXaxis()->FindBin(vars[0]);
+// Printf("Using weight %f", triggerWeighting->GetBinContent(weightBin));
+ useWeight /= triggerWeighting->GetBinContent(weightBin);
+ }
+
+ fNumberDensityPhi->GetEventHist()->Fill(vars, step, useWeight);
+
+ // QA
+ fCorrelationpT->Fill(centrality, triggerParticle->Pt());
+ fCorrelationEta->Fill(centrality, triggerEta);
+ fCorrelationPhi->Fill(centrality, triggerParticle->Phi());
+ fYields->Fill(centrality, triggerParticle->Pt(), triggerEta);
+
+/* if (dynamic_cast<AliAODTrack*>(triggerParticle))
+ fITSClusterMap->Fill(((AliAODTrack*) triggerParticle)->GetITSClusterMap(), centrality, triggerParticle->Pt());*/
}
}
+
+ if (triggerWeighting)
+ {
+ delete triggerWeighting;
+ triggerWeighting = 0;
+ }
}
fCentralityDistribution->Fill(centrality);
}
//____________________________________________________________________
-void AliUEHistograms::FillTrackingEfficiency(TObjArray* mc, TObjArray* recoPrim, TObjArray* recoAll, Int_t particleType, Double_t centrality)
+void AliUEHistograms::FillTrackingEfficiency(TObjArray* mc, TObjArray* recoPrim, TObjArray* recoAll, TObjArray* recoPrimPID, TObjArray* recoAllPID, TObjArray* fake, Int_t particleType, Double_t centrality, Double_t zVtx)
{
// fills the tracking efficiency objects
//
// mc: all primary MC particles
// recoPrim: reconstructed primaries (again MC particles)
// recoAll: reconstructed (again MC particles)
+ // recoPrim: reconstructed primaries with checks on PID (again MC particles)
+ // recoAll: reconstructed with checks on PID (again MC particles)
// particleType is: 0 for pion, 1 for kaon, 2 for proton, 3 for others
-
- for (Int_t step=0; step<3; step++)
+
+ for (Int_t step=0; step<6; step++)
{
TObjArray* list = mc;
if (step == 1)
list = recoPrim;
else if (step == 2)
list = recoAll;
-
+ else if (step == 3)
+ list = recoPrimPID;
+ else if (step == 4)
+ list = recoAllPID;
+ else if (step == 5)
+ list = fake;
+
+ if (!list)
+ continue;
+
for (Int_t i=0; i<list->GetEntriesFast(); i++)
{
- AliVParticle* particle = (AliVParticle*) list->At(i);
- Double_t vars[4];
+ AliVParticle* particle = (AliVParticle*) list->UncheckedAt(i);
+ Double_t vars[5];
vars[0] = particle->Eta();
vars[1] = particle->Pt();
vars[2] = particleType;
vars[3] = centrality;
+ vars[4] = zVtx;
for (Int_t j=0; j<fgkUEHists; j++)
if (GetUEHist(j))
}
}
+//____________________________________________________________________
+void AliUEHistograms::FillFakePt(TObjArray* fake, Double_t centrality)
+{
+ TObjArray* tracksReco = (TObjArray*) fake->At(0);
+ TObjArray* tracksMC = (TObjArray*) fake->At(1);
+
+ if (tracksReco->GetEntriesFast() != tracksMC->GetEntriesFast())
+ AliFatal(Form("Inconsistent arrays: %d vs %d", tracksReco->GetEntriesFast(), tracksMC->GetEntriesFast()));
+
+ for (Int_t i=0; i<tracksReco->GetEntriesFast(); i++)
+ {
+ AliVParticle* particle1 = (AliVParticle*) tracksReco->At(i);
+ AliVParticle* particle2 = (AliVParticle*) tracksMC->At(i);
+ Double_t vars[3];
+ vars[0] = particle1->Pt();
+ vars[1] = particle2->Pt();
+ vars[2] = centrality;
+ for (Int_t j=0; j<fgkUEHists; j++)
+ if (GetUEHist(j))
+ GetUEHist(j)->GetMCRecoPtCorrelation()->Fill(vars[0],vars[1],vars[2]);
+ }
+}
+
//____________________________________________________________________
void AliUEHistograms::FillEvent(Int_t eventType, Int_t step)
{
GetUEHist(i)->SetPtRange(ptMin, ptMax);
}
+//____________________________________________________________________
+void AliUEHistograms::SetPartSpecies(Int_t species)
+{
+ // sets PartSpecie for all contained AliUEHist classes
+
+ for (Int_t i=0; i<fgkUEHists; i++)
+ if (GetUEHist(i))
+ GetUEHist(i)->SetPartSpecies(species);
+}
+
//____________________________________________________________________
void AliUEHistograms::SetZVtxRange(Float_t min, Float_t max)
{
GetUEHist(i)->SetCombineMinMax(flag);
}
+//____________________________________________________________________
+void AliUEHistograms::SetTrackEtaCut(Float_t value)
+{
+ // sets track eta cut for all contained AliUEHist classes
+
+ for (Int_t i=0; i<fgkUEHists; i++)
+ if (GetUEHist(i))
+ GetUEHist(i)->SetTrackEtaCut(value);
+}
+
+//____________________________________________________________________
+void AliUEHistograms::SetWeightPerEvent(Bool_t flag)
+{
+ // sets fWeightPerEvent for all contained AliUEHist classes
+
+ fWeightPerEvent = flag;
+
+ for (Int_t i=0; i<fgkUEHists; i++)
+ if (GetUEHist(i))
+ GetUEHist(i)->SetWeightPerEvent(fWeightPerEvent);
+}
+
//____________________________________________________________________
void AliUEHistograms::Correct(AliUEHistograms* corrections)
{
if (fCorrelationMultiplicity)
target.fCorrelationMultiplicity = dynamic_cast<TH2F*> (fCorrelationMultiplicity->Clone());
+ if (fYields)
+ target.fYields = dynamic_cast<TH3F*> (fYields->Clone());
+
+ if (fInvYield2)
+ target.fInvYield2 = dynamic_cast<TH2F*> (fInvYield2->Clone());
+
if (fEventCount)
target.fEventCount = dynamic_cast<TH2F*> (fEventCount->Clone());
if (fITSClusterMap)
target.fITSClusterMap = dynamic_cast<TH3F*> (fITSClusterMap->Clone());
-
+
+ if (fControlConvResoncances)
+ target.fControlConvResoncances = dynamic_cast<TH2F*> (fControlConvResoncances->Clone());
+
for (Int_t i=0; i<2; i++)
if (fTwoTrackDistancePt[i])
target.fTwoTrackDistancePt[i] = dynamic_cast<TH3F*> (fTwoTrackDistancePt[i]->Clone());
+ if (fEfficiencyCorrectionTriggers)
+ target.fEfficiencyCorrectionTriggers = dynamic_cast<THnF*> (fEfficiencyCorrectionTriggers->Clone());
+
+ if (fEfficiencyCorrectionAssociated)
+ target.fEfficiencyCorrectionAssociated = dynamic_cast<THnF*> (fEfficiencyCorrectionAssociated->Clone());
+
target.fSelectCharge = fSelectCharge;
+ target.fTriggerSelectCharge = fTriggerSelectCharge;
+ target.fAssociatedSelectCharge = fAssociatedSelectCharge;
target.fTriggerRestrictEta = fTriggerRestrictEta;
target.fEtaOrdering = fEtaOrdering;
target.fCutConversions = fCutConversions;
target.fCutResonances = fCutResonances;
+ target.fOnlyOneEtaSide = fOnlyOneEtaSide;
+ target.fWeightPerEvent = fWeightPerEvent;
target.fRunNumber = fRunNumber;
+ target.fMergeCount = fMergeCount;
+ target.fWeightPerEvent = fWeightPerEvent;
+ target.fPtOrder = fPtOrder;
+ target.fTwoTrackCutMinRadius = fTwoTrackCutMinRadius;
}
//____________________________________________________________________
TObject* obj;
// collections of objects
- const Int_t kMaxLists = 17;
+ const Int_t kMaxLists = 20;
TList* lists[kMaxLists];
for (Int_t i=0; i<kMaxLists; i++)
lists[11]->Add(entry->fVertexContributors);
lists[12]->Add(entry->fCentralityDistribution);
lists[13]->Add(entry->fITSClusterMap);
- if (fTwoTrackDistancePt[0])
+ if (entry->fTwoTrackDistancePt[0])
lists[14]->Add(entry->fTwoTrackDistancePt[0]);
- if (fTwoTrackDistancePt[1])
+ if (entry->fTwoTrackDistancePt[1])
lists[15]->Add(entry->fTwoTrackDistancePt[1]);
- if (fCentralityCorrelation)
+ if (entry->fCentralityCorrelation)
lists[16]->Add(entry->fCentralityCorrelation);
+ if (entry->fYields)
+ lists[17]->Add(entry->fYields);
+ if (entry->fInvYield2)
+ lists[18]->Add(entry->fInvYield2);
+ if (entry->fControlConvResoncances)
+ lists[19]->Add(entry->fControlConvResoncances);
+
+ fMergeCount += entry->fMergeCount;
+
count++;
}
fVertexContributors->Merge(lists[11]);
fCentralityDistribution->Merge(lists[12]);
fITSClusterMap->Merge(lists[13]);
- if (fTwoTrackDistancePt[0])
+ if (fTwoTrackDistancePt[0] && lists[14]->GetEntries() > 0)
fTwoTrackDistancePt[0]->Merge(lists[14]);
- if (fTwoTrackDistancePt[1])
+ if (fTwoTrackDistancePt[1] && lists[15]->GetEntries() > 0)
fTwoTrackDistancePt[1]->Merge(lists[15]);
if (fCentralityCorrelation)
fCentralityCorrelation->Merge(lists[16]);
+ if (fYields && lists[17]->GetEntries() > 0)
+ fYields->Merge(lists[17]);
+ if (fInvYield2 && lists[18]->GetEntries() > 0)
+ fInvYield2->Merge(lists[18]);
+ if (fControlConvResoncances && lists[19]->GetEntries() > 0)
+ fControlConvResoncances->Merge(lists[19]);
for (Int_t i=0; i<kMaxLists; i++)
delete lists[i];
-
+
return count+1;
}
GetUEHist(i)->CopyReconstructedData(from->GetUEHist(i));
}
+void AliUEHistograms::DeepCopy(AliUEHistograms* from)
+{
+ // copies the entries of this object's members from the object <from> to this object
+
+ for (Int_t i=0; i<fgkUEHists; i++)
+ if (GetUEHist(i) && from->GetUEHist(i))
+ GetUEHist(i)->DeepCopy(from->GetUEHist(i));
+}
+
void AliUEHistograms::ExtendTrackingEfficiency(Bool_t verbose)
{
// delegates to AliUEHists
list.Add(fCorrelationR);
list.Add(fCorrelationLeading2Phi);
list.Add(fCorrelationMultiplicity);
+ list.Add(fYields);
+ list.Add(fInvYield2);
list.Add(fEventCount);
list.Add(fEventCountDifferential);
list.Add(fVertexContributors);
list.Add(fITSClusterMap);
list.Add(fTwoTrackDistancePt[0]);
list.Add(fTwoTrackDistancePt[1]);
+ list.Add(fControlConvResoncances);
for (Int_t i=0; i<list.GetEntries(); i++)
((TH1*) list.At(i))->Scale(factor);
if (GetUEHist(i))
GetUEHist(i)->Reset();
}
-
-void AliUEHistograms::TwoTrackEfficiency(TObjArray* tracks, TObjArray* mixed, Float_t bSign)
-{
- // takes the input list <tracks> and fills histograms to study two two-track efficiency effects
- // fTwoTrackDistancePt[i] (i = 0 same, i = 1 mixed)
- //
- // the variables have been developed by the HBT group
- // see e.g. https://indico.cern.ch/materialDisplay.py?contribId=36&sessionId=6&materialId=slides&confId=142700
-
- if (!fTwoTrackDistancePt[0])
- {
- fTwoTrackDistancePt[0] = new TH3F("fTwoTrackDistancePt[0]", ";#Delta#eta;#Delta#varphi^{*}_{min};#Delta p_{T}", 100, -0.05, 0.05, 400, -0.2, 0.2, 20, 0, 10);
- fTwoTrackDistancePt[1] = (TH3F*) fTwoTrackDistancePt[0]->Clone("fTwoTrackDistancePt[1]");
- }
-
- // Eta() is extremely time consuming, therefore cache it for the inner loop here:
- TArrayF eta1(tracks->GetEntriesFast());
- for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
- eta1[i] = ((AliVParticle*) tracks->At(i))->Eta();
-
- Int_t jMax = tracks->GetEntriesFast();
- if (mixed)
- jMax = mixed->GetEntriesFast();
-
- TArrayF eta2(jMax);
- if (!mixed)
- eta2 = eta1;
- else
- for (Int_t i=0; i<mixed->GetEntriesFast(); i++)
- eta2[i] = ((AliVParticle*) mixed->At(i))->Eta();
-
- for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
- {
- AliVParticle* particle1 = (AliVParticle*) tracks->At(i);
- Float_t phi1 = particle1->Phi();
- Float_t pt1 = particle1->Pt();
- Float_t charge1 = particle1->Charge();
-
- for (Int_t j=0; j<jMax; j++)
- {
- if (!mixed && i == j)
- continue;
-
- AliVParticle* particle2 = 0;
- if (mixed)
- particle2 = (AliVParticle*) mixed->At(j);
- else
- particle2 = (AliVParticle*) tracks->At(j);
- Float_t phi2 = particle2->Phi();
- Float_t pt2 = particle2->Pt();
- Float_t charge2 = particle2->Charge();
-
- if (pt2 > pt1)
- continue;
-
-// Double_t dpt = TMath::Abs(pt1 - pt2);
- Float_t deta = eta1[i] - eta2[j];
- Float_t detaabs = TMath::Abs(deta);
-
- // optimization
- if (detaabs > 0.05 && (pt1 < 8 || pt1 > 15))
- continue;
-
- Float_t dphistarmin = 1e5;
- Float_t dphistarminabs = 1e5;
-
- for (Double_t rad=0.8; rad<2.51; rad+=0.01)
- {
- Float_t dphistar = phi1 - phi2 - TMath::ASin(charge1 * 0.075 * bSign * rad / pt1) + TMath::ASin(charge2 * 0.075 * bSign * rad / pt2);
- Float_t dphistarabs = TMath::Abs(dphistar);
-
- if (dphistarabs < dphistarminabs)
- {
- dphistarmin = dphistar;
- dphistarminabs = dphistarabs;
- }
- }
-
- Float_t fillPt = pt2;
-
- // analyze region for IAA paper
- if (pt1 < 8 || pt1 > 15)
- fillPt = 0.25;
-
- if (!mixed)
- fTwoTrackDistancePt[0]->Fill(deta, dphistarmin, fillPt);
- else
- fTwoTrackDistancePt[1]->Fill(deta, dphistarmin, fillPt);
- }
- }
-}
-
-Float_t AliUEHistograms::GetInvMassSquared(Float_t pt1, Float_t eta1, Float_t phi1, Float_t pt2, Float_t eta2, Float_t phi2, Float_t m0)
-{
- // calculate inv mass squared
- // same can be achieved, but with more computing time with
- /*TLorentzVector photon, p1, p2;
- p1.SetPtEtaPhiM(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), 0.510e-3);
- p2.SetPtEtaPhiM(particle->Pt(), eta[j], particle->Phi(), 0.510e-3);
- photon = p1+p2;
- photon.M()*/
-
- Float_t tantheta1 = 1e10;
-
- if (eta1 < -1e-10 || eta1 > 1e-10)
- tantheta1 = 2 * TMath::Exp(-eta1) / ( 1 - TMath::Exp(-2*eta1));
-
- Float_t tantheta2 = 1e10;
- if (eta2 < -1e-10 || eta2 > 1e-10)
- tantheta2 = 2 * TMath::Exp(-eta2) / ( 1 - TMath::Exp(-2*eta2));
-
- Float_t e1squ = m0 * m0 + pt1 * pt1 * (1.0 + 1.0 / tantheta1 / tantheta1);
- Float_t e2squ = m0 * m0 + pt2 * pt2 * (1.0 + 1.0 / tantheta2 / tantheta2);
-
- Float_t mass2 = 2 * m0 * m0 + 2 * ( TMath::Sqrt(e1squ * e2squ) - ( pt1 * pt2 * ( TMath::Cos(phi1 - phi2) + 1.0 / tantheta1 / tantheta2 ) ) );
-
- return mass2;
-}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff