fCorrelationLeading2Phi(0),
fCorrelationMultiplicity(0),
fYields(0),
+ fInvYield2(0),
fEventCount(0),
fEventCountDifferential(0),
fVertexContributors(0),
fCentralityCorrelation(0),
fITSClusterMap(0),
fControlConvResoncances(0),
- fEfficiencyCorrection(0),
- fCorrectTriggers(kFALSE),
+ fEfficiencyCorrectionTriggers(0),
+ fEfficiencyCorrectionAssociated(0),
fSelectCharge(0),
fTriggerSelectCharge(0),
+ fAssociatedSelectCharge(0),
fTriggerRestrictEta(-1),
fEtaOrdering(kFALSE),
fCutConversions(kFALSE),
fCutResonances(kFALSE),
+ fRejectResonanceDaughters(-1),
fOnlyOneEtaSide(0),
fWeightPerEvent(kFALSE),
+ fPtOrder(kTRUE),
+ fTwoTrackCutMinRadius(0.8),
fRunNumber(0),
fMergeCount(1)
{
;
// combine customBinning with defaultBinningStr -> use customBinning where available and otherwise defaultBinningStr
- TString customBinning(binning);
- TString binningStr;
-
- TObjArray* lines = defaultBinningStr.Tokenize("\n");
- for (Int_t i=0; i<lines->GetEntriesFast(); i++)
- {
- TString line(lines->At(i)->GetName());
- TString tag = line(0, line.Index(":")+1);
- if (!customBinning.Contains(tag))
- binningStr += line + "\n";
- else
- Printf("Using custom binning for %s", tag.Data());
- }
- delete lines;
- binningStr += customBinning;
+ TString binningStr = AliUEHist::CombineBinning(defaultBinningStr, TString(binning));
if (histogramsStr.Contains("1"))
fNumberDensitypT = new AliUEHist("NumberDensitypT", binningStr);
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);
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"))
{
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", 101, 0, 101, 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);
fCorrelationLeading2Phi(0),
fCorrelationMultiplicity(0),
fYields(0),
+ fInvYield2(0),
fEventCount(0),
fEventCountDifferential(0),
fVertexContributors(0),
fCentralityCorrelation(0),
fITSClusterMap(0),
fControlConvResoncances(0),
- fEfficiencyCorrection(0),
- fCorrectTriggers(kFALSE),
+ fEfficiencyCorrectionTriggers(0),
+ fEfficiencyCorrectionAssociated(0),
fSelectCharge(0),
fTriggerSelectCharge(0),
+ fAssociatedSelectCharge(0),
fTriggerRestrictEta(-1),
fEtaOrdering(kFALSE),
fCutConversions(kFALSE),
fCutResonances(kFALSE),
+ fRejectResonanceDaughters(-1),
fOnlyOneEtaSide(0),
fWeightPerEvent(kFALSE),
+ fPtOrder(kTRUE),
+ fTwoTrackCutMinRadius(0.8),
fRunNumber(0),
fMergeCount(1)
{
fYields = 0;
}
+ if (fInvYield2)
+ {
+ delete fInvYield2;
+ fInvYield2 = 0;
+ }
+
if (fEventCount)
{
delete fEventCount;
fControlConvResoncances = 0;
}
- if (fEfficiencyCorrection)
+ if (fEfficiencyCorrectionTriggers)
{
- delete fEfficiencyCorrection;
- fEfficiencyCorrection = 0;
+ delete fEfficiencyCorrectionTriggers;
+ fEfficiencyCorrectionTriggers = 0;
+ }
+
+ if (fEfficiencyCorrectionAssociated)
+ {
+ delete fEfficiencyCorrectionAssociated;
+ fEfficiencyCorrectionAssociated = 0;
}
}
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)
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();
triggerWeighting->Fill(triggerParticle->Pt());
}
-// new TCanvas; triggerWeighting->Draw();
+ }
+
+ // 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 (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, 0.510e-3);
+ Float_t mass = GetInvMassSquaredCheap(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.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
if (fCutResonances && particle->Charge() * triggerParticle->Charge() < 0)
{
- Float_t mass = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.1396);
+ Float_t mass = GetInvMassSquaredCheap(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.1396);
const Float_t kK0smass = 0.4976;
- fControlConvResoncances->Fill(1, mass - kK0smass*kK0smass);
+ 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;
+ 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 = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.1396, 0.9383);
- Float_t mass2 = GetInvMassSquared(triggerParticle->Pt(), triggerEta, triggerParticle->Phi(), particle->Pt(), eta[j], particle->Phi(), 0.9383, 0.1396);
+ 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;
- fControlConvResoncances->Fill(2, mass1 - kLambdaMass*kLambdaMass);
- fControlConvResoncances->Fill(2, mass2 - kLambdaMass*kLambdaMass);
+ 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);
- if ((mass1 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass1 < (kLambdaMass+0.02)*(kLambdaMass+0.02)) ||
- (mass2 > (kLambdaMass-0.02)*(kLambdaMass-0.02) && mass2 < (kLambdaMass+0.02)*(kLambdaMass+0.02)))
- continue;
+ 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)
if (TMath::Abs(deta) < twoTrackEfficiencyCutValue * 2.5 * 3)
{
// check first boundaries to see if is worth to loop and find the minimum
- Float_t dphistar1 = GetDPhiStar(phi1, pt1, charge1, phi2, pt2, charge2, 0.8, bSign);
+ 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;
Float_t dphistarmin = 1e5;
if (TMath::Abs(dphistar1) < kLimit || TMath::Abs(dphistar2) < kLimit || dphistar1 * dphistar2 < 0)
{
- for (Double_t rad=0.8; rad<2.51; rad+=0.01)
+ for (Double_t rad=fTwoTrackCutMinRadius; rad<2.51; rad+=0.01)
{
Float_t dphistar = GetDPhiStar(phi1, pt1, charge1, phi2, pt2, charge2, rad, bSign);
weight = particle->Pt();
Double_t useWeight = weight;
- if (fEfficiencyCorrection && applyEfficiency)
+ if (applyEfficiency)
{
- Int_t effVars[4];
-
- // associated particle
- effVars[0] = fEfficiencyCorrection->GetAxis(0)->FindBin(eta[j]);
- effVars[1] = fEfficiencyCorrection->GetAxis(1)->FindBin(vars[1]); //pt
- effVars[2] = fEfficiencyCorrection->GetAxis(2)->FindBin(vars[3]); //centrality
- effVars[3] = fEfficiencyCorrection->GetAxis(3)->FindBin(vars[5]); //zVtx
-
-// Printf("%d %d %d %d %f", effVars[0], effVars[1], effVars[2], effVars[3], fEfficiencyCorrection->GetBinContent(effVars));
-
- useWeight *= fEfficiencyCorrection->GetBinContent(effVars);
+ 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));
- // trigger particle
- if (fCorrectTriggers)
+ useWeight *= fEfficiencyCorrectionAssociated->GetBinContent(effVars);
+ }
+ if (fEfficiencyCorrectionTriggers)
{
- effVars[0] = fEfficiencyCorrection->GetAxis(0)->FindBin(triggerEta);
- effVars[1] = fEfficiencyCorrection->GetAxis(1)->FindBin(vars[2]); //pt
- useWeight *= fEfficiencyCorrection->GetBinContent(effVars);
+ 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]);
}
// fill all in toward region and do not use the other regions
- fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step, useWeight);
-
+ fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step, useWeight);
+
// Printf("%.2f %.2f --> %.2f", triggerEta, eta[j], vars[0]);
}
vars[2] = zVtx;
Double_t useWeight = 1;
- if (fEfficiencyCorrection && applyEfficiency && fCorrectTriggers)
+ if (fEfficiencyCorrectionTriggers && applyEfficiency)
{
Int_t effVars[4];
// trigger particle
- effVars[0] = fEfficiencyCorrection->GetAxis(0)->FindBin(triggerEta);
- effVars[1] = fEfficiencyCorrection->GetAxis(1)->FindBin(vars[0]); //pt
- effVars[2] = fEfficiencyCorrection->GetAxis(2)->FindBin(vars[1]); //centrality
- effVars[3] = fEfficiencyCorrection->GetAxis(3)->FindBin(vars[2]); //zVtx
- useWeight *= fEfficiencyCorrection->GetBinContent(effVars);
+ 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
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());*/
}
}
//____________________________________________________________________
-void AliUEHistograms::FillTrackingEfficiency(TObjArray* mc, TObjArray* recoPrim, TObjArray* recoAll, TObjArray* fake, Int_t particleType, Double_t centrality, Double_t zVtx)
+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<4; step++)
+ for (Int_t step=0; step<6; step++)
{
TObjArray* list = mc;
if (step == 1)
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)
for (Int_t i=0; i<list->GetEntriesFast(); i++)
{
- AliVParticle* particle = (AliVParticle*) list->At(i);
+ AliVParticle* particle = (AliVParticle*) list->UncheckedAt(i);
Double_t vars[5];
vars[0] = particle->Eta();
vars[1] = particle->Pt();
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)
{
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 (fTwoTrackDistancePt[i])
target.fTwoTrackDistancePt[i] = dynamic_cast<TH3F*> (fTwoTrackDistancePt[i]->Clone());
- if (fEfficiencyCorrection)
- target.fEfficiencyCorrection = dynamic_cast<THnF*> (fEfficiencyCorrection->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.fWeightPerEvent = fWeightPerEvent;
target.fRunNumber = fRunNumber;
target.fMergeCount = fMergeCount;
- target.fCorrectTriggers = fCorrectTriggers;
+ target.fWeightPerEvent = fWeightPerEvent;
+ target.fPtOrder = fPtOrder;
+ target.fTwoTrackCutMinRadius = fTwoTrackCutMinRadius;
}
//____________________________________________________________________
TObject* obj;
// collections of objects
- const Int_t kMaxLists = 19;
+ const Int_t kMaxLists = 20;
TList* lists[kMaxLists];
for (Int_t i=0; i<kMaxLists; i++)
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[18]->Add(entry->fControlConvResoncances);
+ lists[19]->Add(entry->fControlConvResoncances);
fMergeCount += entry->fMergeCount;
fCentralityCorrelation->Merge(lists[16]);
if (fYields && lists[17]->GetEntries() > 0)
fYields->Merge(lists[17]);
- if (fControlConvResoncances && lists[18]->GetEntries() > 0)
- fControlConvResoncances->Merge(lists[18]);
+ 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];
list.Add(fCorrelationLeading2Phi);
list.Add(fCorrelationMultiplicity);
list.Add(fYields);
+ list.Add(fInvYield2);
list.Add(fEventCount);
list.Add(fEventCountDifferential);
list.Add(fVertexContributors);
if (GetUEHist(i))
GetUEHist(i)->Reset();
}
-
-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_1, Float_t m0_2)
-{
- // 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_1 * m0_1 + pt1 * pt1 * (1.0 + 1.0 / tantheta1 / tantheta1);
- Float_t e2squ = m0_2 * m0_2 + pt2 * pt2 * (1.0 + 1.0 / tantheta2 / tantheta2);
-
- Float_t mass2 = m0_1 * m0_1 + m0_2 * m0_2 + 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