if ((mask & kInel) != 0x0) trg.Append("INEL ");
if ((mask & kInelGt0) != 0x0) trg.Append("INEL>0 ");
if ((mask & kNSD) != 0x0) trg.Append("NSD ");
+ if ((mask & kV0AND) != 0x0) trg.Append("V0AND ");
if ((mask & kA) != 0x0) trg.Append("A ");
if ((mask & kB) != 0x0) trg.Append("B ");
if ((mask & kC) != 0x0) trg.Append("C ");
ret->GetXaxis()->SetBinLabel(kBinInel, "Minimum Bias");
ret->GetXaxis()->SetBinLabel(kBinInelGt0, "INEL>0");
ret->GetXaxis()->SetBinLabel(kBinNSD, "NSD");
+ ret->GetXaxis()->SetBinLabel(kBinV0AND, "V0AND");
ret->GetXaxis()->SetBinLabel(kBinMCNSD, "NSD (MC truth)");
ret->GetXaxis()->SetBinLabel(kBinPileUp, "w/Pileup");
ret->GetXaxis()->SetBinLabel(kBinOffline, "w/Offline");
if (s.CompareTo("INEL") == 0) trgMask |= AliAODForwardMult::kInel;
else if (s.CompareTo("INEL>0")== 0) trgMask |= AliAODForwardMult::kInelGt0;
else if (s.CompareTo("NSD") == 0) trgMask |= AliAODForwardMult::kNSD;
+ else if (s.CompareTo("V0AND") == 0) trgMask |= AliAODForwardMult::kV0AND;
else if (s.CompareTo("MCNSD") == 0) trgMask |= AliAODForwardMult::kMCNSD;
else if (s.CompareTo("B") == 0) trgMask |= AliAODForwardMult::kB;
else if (s.CompareTo("A") == 0) trgMask |= AliAODForwardMult::kA;
if (IsTriggerBits(kB|kInel)) hist->AddBinContent(kBinInel);
if (IsTriggerBits(kB|kInelGt0)) hist->AddBinContent(kBinInelGt0);
if (IsTriggerBits(kB|kNSD)) hist->AddBinContent(kBinNSD);
+ if (IsTriggerBits(kB|kV0AND)) hist->AddBinContent(kBinV0AND);
if (IsTriggerBits(kPileUp)) hist->AddBinContent(kBinPileUp);
if (IsTriggerBits(kMCNSD)) hist->AddBinContent(kBinMCNSD);
if (IsTriggerBits(kOffline)) hist->AddBinContent(kBinOffline);
/** Offline MB triggered */
kOffline = 0x800,
/** At least one SPD cluster */
- kNClusterGt0 = 0x1000
+ kNClusterGt0 = 0x1000,
+ /** V0-AND trigger */
+ kV0AND
};
/**
* Bin numbers in trigger histograms
kBinInel,
kBinInelGt0,
kBinNSD,
+ kBinV0AND,
kBinA,
kBinB,
kBinC,
* @param dbg Debug level
*/
void SetDebug(Int_t dbg=1) { fDebug = dbg; }
- /**
+ /**
* Set to use the running average in Poisson
*
* @param use use or not
* @param u If >0, use the phi acceptance (default is false)
*/
void SetUsePhiAcceptance(UShort_t u=kPhiCorrectNch) { fUsePhiAcceptance = u; }
- /**
- * Set the lower multiplicity cut. This overrides the setting in
- * the energy loss fits.
- *
- * @param cut Cut to use
- */
- void SetMultCut(Double_t cut) { fCuts.SetMultCuts(cut,cut,cut,cut,cut); }
- /**
- * Set the lower multiplicity cuts
- *
- * @param fmd1i Lower mulitplicyt cut for FMD1i
- * @param fmd2i Lower mulitplicyt cut for FMD2i
- * @param fmd2o Lower mulitplicyt cut for FMD2o
- * @param fmd3i Lower mulitplicyt cut for FMD3i
- * @param fmd3o Lower mulitplicyt cut for FMD3o
- */
- void SetMultCuts(Double_t fmd1i,
- Double_t fmd2i,
- Double_t fmd2o,
- Double_t fmd3i,
- Double_t fmd3o);
/**
* Set the luming factors used in the Poisson method
*
fEtaLumping = (eta < 1 ? 1 : eta);
fPhiLumping = (phi < 1 ? 1 : phi);
}
- /**
- * Set the number of landau width to subtract from the most probably
- * value to get the low cut.
- *
- * @param nXi Number of @f$ \xi@f$
- */
- void SetNXi(Double_t nXi) { fCuts.SetNXi(nXi); /* fNXi = nXi;*/ }
- /**
- * Whether to include sigma in the number subtracted from the MPV to
- * get the low cut
- *
- * @param u If true, then low cut is @f$ \Delta_{mp} - n(\xi+\sigma)@f$
- */
- void SetIncludeSigma(Bool_t u) { fCuts.SetIncludeSigma(u); /*fIncludeSigma = u;*/ }
- /**
- *
- * Set the fraction of MPV
- *
- * @param cut if true cut at fraction of MPV
- */
- void SetFractionOfMPV(Double_t cut) { fCuts.SetMPVFraction(cut); /*fFractionOfMPV = cut;*/ }
/**
* Get the multiplicity cut. If the user has set fMultCut (via
* SetMultCut) then that value is used. If not, then the lower
* @param nEvents Number of events
*/
void ScaleHistograms(TList* dir, Int_t nEvents);
-#if 0
- /**
- * Create Poisson histograms
- */
- void ResetPoissonHistos(const TH2D* h, Int_t etaLumping, Int_t phiLumping);
-#endif
TH2D* fEvsN; // Correlation of Eloss vs uncorrected Nch
TH2D* fEvsM; // Correlation of Eloss vs corrected Nch
TProfile* fEtaVsN; // Average uncorrected Nch vs eta
TProfile* fCorr; // Average correction vs eta
TH2D* fDensity; // Distribution inclusive Nch
TH2D* fELossVsPoisson; // Correlation of energy loss vs Poisson N_ch
-#if 0
- TH2D* fTotalStrips; // Total number of strips in a region
- TH2D* fEmptyStrips; // Total number of strips in a region
- TH2D* fBasicHits ; // Total number basic hits in a region
- TH2D* fEmptyVsTotal; // # of empty strips vs total number of
- // # # strips
-#else
AliPoissonCalculator fPoisson; // Calculate density using Poisson method
-#endif
TH1D* fELoss; // Energy loss as seen by this
TH1D* fELossUsed; // Energy loss in strips with signal
Double_t fMultCut; // If set, use this
- ClassDef(RingHistos,5);
+ ClassDef(RingHistos,6);
};
/**
* Get the ring histogram container
#include <TList.h>
#include <TDirectory.h>
#include <TROOT.h>
+#include <TParameter.h>
#include <iostream>
#include <iomanip>
fCentAxis(0),
fVtxAxis(10,-10,10),
fUseFirstPhysicsVertex(true),
- fUseV0AND(false)
+ fUseV0AND(false),
+ fMinPileupContrib(3),
+ fMinPileupDistance(0.8)
{
//
// Constructor
fCentAxis(0),
fVtxAxis(10,-10,10),
fUseFirstPhysicsVertex(true),
- fUseV0AND(false)
+ fUseV0AND(false),
+ fMinPileupContrib(3),
+ fMinPileupDistance(0.8)
{
//
// Constructor
fCentAxis(0),
fVtxAxis(o.fVtxAxis),
fUseFirstPhysicsVertex(o.fUseFirstPhysicsVertex),
- fUseV0AND(o.fUseV0AND)
+ fUseV0AND(o.fUseV0AND),
+ fMinPileupContrib(o.fMinPileupContrib),
+ fMinPileupDistance(o.fMinPileupDistance)
{
//
// Copy constructor
fUseFirstPhysicsVertex = o.fUseFirstPhysicsVertex;
fUseV0AND = o.fUseV0AND;
+ fMinPileupContrib = o.fMinPileupContrib;
+ fMinPileupDistance = o.fMinPileupDistance;
if (fList) {
fList->SetName(GetName());
fHTriggers->GetXaxis()->SetBinLabel(kInel +1,"INEL");
fHTriggers->GetXaxis()->SetBinLabel(kInelGt0+1,"INEL>0");
fHTriggers->GetXaxis()->SetBinLabel(kNSD +1,"NSD");
+ fHTriggers->GetXaxis()->SetBinLabel(kV0AND +1,"VOAND");
fHTriggers->GetXaxis()->SetBinLabel(kEmpty +1,"Empty");
fHTriggers->GetXaxis()->SetBinLabel(kA +1,"A");
fHTriggers->GetXaxis()->SetBinLabel(kB +1,"B");
TNamed* sNN = new TNamed("sNN", "");
TNamed* fld = new TNamed("field", "");
TNamed* run = new TNamed("runNo", Form("%d", runNo));
+ TNamed* low = new TNamed("lowFlux", Form("%d", fLowFluxCut));
+ TNamed* fpv = new TNamed("fpVtx", Form("%s", fUseFirstPhysicsVertex ? "true" : "false"));
+ TNamed* v0a = new TNamed("v0and", Form("%s", fUseV0AND ? "true" : "false"));
+ TNamed* nCp = new TNamed("nPileup", Form("%d", fMinPileupContrib));
sys->SetTitle(AliForwardUtil::CollisionSystemString(fCollisionSystem));
sNN->SetTitle(AliForwardUtil::CenterOfMassEnergyString(fEnergy));
fld->SetTitle(AliForwardUtil::MagneticFieldString(fField));
sNN->SetUniqueID(fEnergy);
fld->SetUniqueID(fField);
run->SetUniqueID(runNo);
+ low->SetUniqueID(fLowFluxCut);
+ fpv->SetUniqueID(fUseFirstPhysicsVertex ? 1 : 0);
+ v0a->SetUniqueID(fUseV0AND ? 1 : 0);
+ nCp->SetUniqueID(fMinPileupContrib);
+ TParameter<Double_t>* dP = new TParameter<Double_t>("dPileup", fMinPileupDistance);
fList->Add(sys);
fList->Add(sNN);
fList->Add(fld);
- fList->Add(run);
+ fList->Add(run);
+ fList->Add(low);
+ fList->Add(fpv);
+ fList->Add(v0a);
+ fList->Add(nCp);
+ fList->Add(dP);
+
+
}
//____________________________________________________________________
if(offline && trigStr.Contains("CMUS1")) offline = false;
- if (offline ) {
+ if (offline) {
triggers |= AliAODForwardMult::kOffline;
triggers |= AliAODForwardMult::kInel;
fHTriggers->Fill(kOffline+0.5);
// Analyse some trigger stuff
AliTriggerAnalysis ta;
- if(fUseV0AND) {
- if (ta.IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0AND))
- triggers |= AliAODForwardMult::kNSD;
- }
- else {
- if (ta.IsOfflineTriggerFired(esd, AliTriggerAnalysis::kNSD1))
+ if (ta.IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0AND)) {
+ triggers |= AliAODForwardMult::kV0AND;
+ if (fUseV0AND)
triggers |= AliAODForwardMult::kNSD;
}
+ if (ta.IsOfflineTriggerFired(esd, AliTriggerAnalysis::kNSD1))
+ triggers |= AliAODForwardMult::kNSD;
// Check for multiple vertices (pile-up) with at least 3
// contributors and at least 0.8cm from the primary vertex
Bool_t pileup = kFALSE;
if(fCollisionSystem == AliForwardUtil::kPP)
- pileup = esd->IsPileupFromSPD(3,0.8);
+ pileup = esd->IsPileupFromSPD(fMinPileupContrib,fMinPileupDistance);
if (pileup) {
triggers |= AliAODForwardMult::kPileUp;
fHTriggers->Fill(kPileUp+.5);
if (triggers & AliAODForwardMult::kNSD)
fHTriggers->Fill(kNSD+.5);
+
+ if (triggers & AliAODForwardMult::kV0AND)
+ fHTriggers->Fill(kV0AND+.5);
}
return kTRUE;
<< "," << fVtxAxis.GetXmax() << "]\n"
<< ind << " Low flux cut: " << fLowFluxCut << '\n'
<< ind << " Max(delta v_z): " << fMaxVzErr << " cm\n"
+ << ind << " Min(nContrib_pileup): " << fMinPileupContrib << '\n'
+ << ind << " Min(v-pileup): " << fMinPileupDistance << '\n'
<< ind << " System: "
<< AliForwardUtil::CollisionSystemString(fCollisionSystem) << '\n'
<< ind << " CMS energy per nucleon: " << sNN << '\n'
enum ETrgBins {
kInel,
kInelGt0,
- kNSD,
+ kNSD,
+ kV0AND,
kEmpty,
kA,
kB,
*
* @param use Use it or not
*/
- void SetUseV0AndForNSD(Bool_t use) {fUseV0AND = use; }
+ void SetUseV0AndForNSD(Bool_t use=true) {fUseV0AND = use; }
+ /**
+ * Set the minimum number of contributors for a 2nd pile-up vertex
+ *
+ * @param nContrib Least number of contributors
+ */
+ void SetMinPileupContributors(UShort_t nContrib=3)
+ {
+ fMinPileupContrib = nContrib;
+ }
+ /**
+ * Set minimum distance from primary vertex to 2nd pile-up vertex
+ *
+ * @param cm Distance (in centimeters)
+ */
+ void SetMinPileupDistance(Double_t cm=0.8)
+ {
+ fMinPileupDistance = cm;
+ }
/**
* Set the debug level. The higher the value the more output
*
TAxis fVtxAxis; //Vtx Axis
Bool_t fUseFirstPhysicsVertex; //Use the vtx code from p+p first physics
Bool_t fUseV0AND; //Use the vtx code from p+p first physics
- ClassDef(AliFMDEventInspector,3); // Inspect the event
+ UShort_t fMinPileupContrib; // Minimum number of contributors to 2nd
+ // pile-up vertex
+ Double_t fMinPileupDistance; // Minimum distance of 2nd pile-up
+ // vertex
+ ClassDef(AliFMDEventInspector,4); // Inspect the event
};
#endif
: TNamed(),
fRingHistos(),
fCorrectAngles(kFALSE),
- fNXi(1),
- fIncludeSigma(true),
fSummed(0),
fHighCuts(0),
fLowCuts(0),
: TNamed("fmdSharingFilter", title),
fRingHistos(),
fCorrectAngles(kFALSE),
- fNXi(1),
- fIncludeSigma(true),
fSummed(0),
fHighCuts(0),
fLowCuts(0),
: TNamed(o),
fRingHistos(),
fCorrectAngles(o.fCorrectAngles),
- fNXi(o.fNXi),
- fIncludeSigma(o.fIncludeSigma),
fSummed(o.fSummed),
fHighCuts(o.fHighCuts),
fLowCuts(o.fLowCuts),
TNamed::operator=(o);
fCorrectAngles = o.fCorrectAngles;
- fNXi = o.fNXi;
fDebug = o.fDebug;
fOper = o.fOper;
fSummed = o.fSummed;
fHighCuts = o.fHighCuts;
fLowCuts = o.fLowCuts;
- fIncludeSigma = o.fIncludeSigma;
fZeroSharedHitsBelowThreshold = o.fZeroSharedHitsBelowThreshold;
fLCuts = o.fLCuts;
fHCuts = o.fHCuts;
// 2 times the width of the corresponding Landau.
//
return fHCuts.GetMultCut(d,r,eta,errors);
-#if 0
- AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
-
-
- // Get the high cut. The high cut is defined as the
- // most-probably-value peak found from the energy distributions, minus
- // 2 times the width of the corresponding Landau.
- AliFMDCorrELossFit* fits = fcm.GetELossFit();
-
- return fits->GetLowerBound(d, r, eta, fNXi, errors, fIncludeSigma);
-#endif
}
//_____________________________________________________________________
fLowCuts->SetDirectory(0);
d->Add(fLowCuts);
- // TParameter<double>* lowCut = new TParameter<double>("lowCut", fLowCut);
- // TParameter<double>* nXi = new TParameter<double>("nXi", fNXi);
- // TNamed* sigma = new TNamed("sigma", fIncludeSigma ?
- // "included" : "excluded");
- // sigma->SetUniqueID(fIncludeSigma);
TNamed* angle = new TNamed("angle", fCorrectAngles ?
"corrected" : "uncorrected");
angle->SetUniqueID(fCorrectAngles);
*
*/
void Init();
- /**
- * Set the low cut used for sharing
- *
- * @param lowCut Low cut
- */
- void SetLowCut(Double_t lowCut=0) { fLCuts.SetMultCuts(lowCut); }
- /**
- * Reset the low cut for sharing to use the fit range lower cut
- *
- */
- void UnsetLowCut() { fLCuts.SetMultCuts(0); }
/**
* Set the debug level. The higher the value the more output
*
*
*/
void SetAllow3Strips(Bool_t use) { fThreeStripSharing = use; }
- /**
- * Set the number of landau width to subtract from the most probably
- * value to get the high cut for the merging algorithm.
- *
- * @param n Number of @f$ \xi@f$
- */
- void SetNXi(Double_t n) { fHCuts.SetNXi(n); /* fNXi = n; */ }
- /**
- * Whether to include sigma in the number subtracted from the MPV to
- * get the high cut
- *
- * @param u If true, then high cut is @f$ \Delta_{mp} - n(\xi+\sigma)@f$
- */
- void SetIncludeSigma(Bool_t u) { fHCuts.SetIncludeSigma(u); /*fIncludeSigma = u;*/ }
/**
* Filter the input AliESDFMD object
*
Bool_t Filter(const AliESDFMD& input,
Bool_t lowFlux,
AliESDFMD& output);
- /**
- *
- * Set the fraction of MPV
- *
- * @param cut Fraction of MPV
- */
- void SetFractionOfMPV(Double_t cut) { fHCuts.SetMPVFraction(cut); }
/**
* Scale the histograms to the total number of events
*
TList fRingHistos; // List of histogram containers
// Double_t fLowCut; // Low cut on sharing
Bool_t fCorrectAngles; // Whether to work on angle corrected signals
- Double_t fNXi; // Number of xi's from Delta to stop merging
- Bool_t fIncludeSigma; // Whether to include sigma in cut
TH2* fSummed; // Operations histogram
TH2* fHighCuts; // High cuts used
TH2* fLowCuts; // High cuts used
AliFMDMultCuts fHCuts; //Cuts object for high cuts
Bool_t fUseSimpleMerging; //enable simple sharing by HHD
Bool_t fThreeStripSharing; //In case of simple sharing allow 3 strips
- ClassDef(AliFMDSharingFilter,3); //
+ ClassDef(AliFMDSharingFilter,4); //
};
#endif
task->GetEventInspector().SetLowFluxCut(1000);
// Set the maximum error on v_z [cm]
task->GetEventInspector().SetMaxVzErr(0.2);
+ // Least number of constributors to 2nd pile-up vertex
+ task->GetEventInspector().SetMinPileupContributors(3);
+ // Least distance from primary to 2nd pile-up vertex (cm)
+ task->GetEventInspector().SetMinPileupDistance(.8);
+ // V0-AND triggered events flagged as NSD
+ task->GetEventInspector().SetUseV0AndForNSD(false);
+ // Use primary vertex selection from 1st physics WG
+ task->GetEventInspector().SetUseFirstPhysicsVertex(false);
// --- Sharing filter ----------------------------------------------
// Set the low cut used for sharing - overrides settings in eloss fits
task->GetSharingFilter().SetUseAngleCorrectedSignals(true);
// Disable use of angle corrected signals in the algorithm
task->GetSharingFilter().SetZeroSharedHitsBelowThreshold(false);
- // Enable use of angle corrected signals in the algorithm
+ // Whether to use simple merging algorithm
+ task->GetSharingFilter().SetUseSimpleSharing(false);
+ // Whether to allow for 3 strip hits
+ task->GetSharingFilter().SetAllow3Strips(true);
+ // Do not cut fixed/hard on multiplicity
task->GetSharingFilter().GetHCuts().SetMultCuts(-1);
// Set the number of xi's (width of landau peak) to stop at
task->GetSharingFilter().GetHCuts().SetNXi(nXi);
task->GetDensityCalculator().SetMaxParticles(10);
// Wet whether to use poisson statistics to estimate N_ch
task->GetDensityCalculator().SetUsePoisson(true);
+ // Set to use the running average in Poisson
+ task->GetDensityCalculator().SetUseRunningAverage(false);
// Set whether or not to include sigma in cut
task->GetDensityCalculator().SetCuts(cDensity);
-
+ // Set lumping (nEta,nPhi)
+ task->GetDensityCalculator().SetLumping(32,4);
// Set whether or not to use the phi acceptance
// AliFMDDensityCalculator::kPhiNoCorrect
// AliFMDDensityCalculator::kPhiCorrectNch
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff