//____________________________________________________________
AliHFEInclusiveSpectrum::AliHFEInclusiveSpectrum(const char *name):
AliHFECorrectSpectrumBase(name),
- fQA(NULL)
+ fQA(NULL),
+ fNoCentralitySelectionMC(kFALSE)
{
//
// Default constructor
//____________________________________________________________
AliHFEInclusiveSpectrum::AliHFEInclusiveSpectrum(const AliHFEInclusiveSpectrum &ref):
AliHFECorrectSpectrumBase(ref),
- fQA(ref.fQA)
+ fQA(ref.fQA),
+ fNoCentralitySelectionMC(ref.fNoCentralitySelectionMC)
{
//
// Copy constructor
//
AliHFEInclusiveSpectrum &target = dynamic_cast<AliHFEInclusiveSpectrum &>(o);
target.fQA = fQA;
+ target.fNoCentralitySelectionMC = fNoCentralitySelectionMC;
}
}
//____________________________________________________________
-Bool_t AliHFEInclusiveSpectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHFEcontainer *mchfecontainer, const AliHFEcontainer *v0hfecontainer, const AliHFEcontainer */*bghfecontainer*/){
+Bool_t AliHFEInclusiveSpectrum::Init(const AliHFEcontainer *datahfecontainer, const AliHFEcontainer *mchfecontainer, const AliHFEcontainer */*bghfecontainer*/, const AliHFEcontainer *v0hfecontainer,AliCFContainer *photoniccontainerD){
//
// Init what we need for the correction:
//
//
//
- Int_t kNdim = 3;
+
+ Bool_t centralitySelectionData = kTRUE, centralitySelectionMC = !fNoCentralitySelectionMC;
- Int_t dims[kNdim];
- switch(fNbDimensions){
- case 1: dims[0] = 0;
- break;
- case 2: for(Int_t i = 0; i < 2; i++) dims[i] = i;
- break;
- case 3: for(Int_t i = 0; i < 3; i++) dims[i] = i;
- break;
- default:
- AliError("Container with this number of dimensions not foreseen (yet)");
- return kFALSE;
- };
-
//
- // Data container: raw spectrum + hadron contamination
- //
+ // Data container: raw spectrum + hadron contamination
+ //
AliCFContainer *datacontainer = datahfecontainer->GetCFContainer("recTrackContReco");
AliCFContainer *contaminationcontainer = datahfecontainer->GetCFContainer("hadronicBackground");
if((!datacontainer) || (!contaminationcontainer)) return kFALSE;
- AliCFContainer *datacontainerD = GetSlicedContainer(datacontainer, fNbDimensions, dims, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
- AliCFContainer *contaminationcontainerD = GetSlicedContainer(contaminationcontainer, fNbDimensions, dims, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
+ AliCFContainer *datacontainerD = GetSlicedContainer(datacontainer, fNbDimensions, fDims, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionData);
+ AliCFContainer *contaminationcontainerD = GetSlicedContainer(contaminationcontainer, fNbDimensions, fDims, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionData);
if((!datacontainerD) || (!contaminationcontainerD)) return kFALSE;
SetContainer(datacontainerD,AliHFECorrectSpectrumBase::kDataContainer);
SetContainer(contaminationcontainerD,AliHFECorrectSpectrumBase::kBackgroundData);
+
+ // Photonic Background
+ SetContainer(photoniccontainerD,AliHFECorrectSpectrumBase::kPhotonicBackground);
+
// QA
Int_t dimqa = datacontainer->GetNVar();
Int_t dimsqa[dimqa];
for(Int_t i = 0; i < dimqa; i++) dimsqa[i] = i;
- AliCFContainer *datacontainerDQA = GetSlicedContainer(datacontainer, dimqa, dimsqa, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
+ AliCFContainer *datacontainerDQA = GetSlicedContainer(datacontainer, dimqa, dimsqa, -1, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionData);
fQA->AddResultAt(datacontainerDQA,AliHFEInclusiveSpectrumQA::kDataProjection);
//
mccontainermc = mchfecontainer->MakeMergedCFContainer("summc","summc","MCTrackCont:recTrackContMC");
if((!mccontaineresd) || (!mccontainermc)) return kFALSE;
Int_t source = -1;
- AliCFContainer *mccontaineresdD = GetSlicedContainer(mccontaineresd, fNbDimensions, dims, source, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
- AliCFContainer *mccontainermcD = GetSlicedContainer(mccontainermc, fNbDimensions, dims, source, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
+ AliCFContainer *mccontaineresdD = GetSlicedContainer(mccontaineresd, fNbDimensions, fDims, source, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionMC);
+ AliCFContainer *mccontainermcD = GetSlicedContainer(mccontainermc, fNbDimensions, fDims, source, fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionMC);
if((!mccontaineresdD) || (!mccontainermcD)) return kFALSE;
SetContainer(mccontainermcD,AliHFECorrectSpectrumBase::kMCContainerMC);
SetContainer(mccontaineresdD,AliHFECorrectSpectrumBase::kMCContainerESD);
THnSparseF *mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepbeforePID");
if(!mccorrelation) mccorrelation = mchfecontainer->GetCorrelationMatrix("correlationstepafterPID");
if(!mccorrelation) return kFALSE;
- THnSparseF *mccorrelationD = GetSlicedCorrelation(mccorrelation, fNbDimensions, dims,fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
+ THnSparseF *mccorrelationD = GetSlicedCorrelation(mccorrelation, fNbDimensions, fDims,fChargeChoosen,fTestCentralityLow,fTestCentralityHigh, centralitySelectionMC);
if(!mccorrelationD) {
printf("No correlation\n");
return kFALSE;
if(v0hfecontainer) {
AliCFContainer *containerV0 = v0hfecontainer->GetCFContainer("taggedTrackContainerReco");
if(!containerV0) return kFALSE;
- AliCFContainer *containerV0Electron = GetSlicedContainer(containerV0, fNbDimensions, dims, AliPID::kElectron,fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
+ AliCFContainer *containerV0Electron = GetSlicedContainer(containerV0, fNbDimensions, fDims, AliPID::kElectron,fChargeChoosen,fTestCentralityLow,fTestCentralityHigh);
if(!containerV0Electron) return kFALSE;
SetContainer(containerV0Electron,AliHFECorrectSpectrumBase::kDataContainerV0);
}
return kTRUE;
}
//____________________________________________________________
-Bool_t AliHFEInclusiveSpectrum::Correct(Bool_t subtractcontamination){
+Bool_t AliHFEInclusiveSpectrum::Correct(Bool_t subtractcontamination, Bool_t subtractphotonic){
//
// Correct the spectrum for efficiency and unfolding
// with both method and compare
AliInfo("You have to init before");
return kFALSE;
}
-
+
if((fStepTrue < 0) && (fStepMC < 0) && (fStepData < 0)) {
AliInfo("You have to set the steps before: SetMCTruthStep, SetMCEffStep, SetStepToCorrect");
return kFALSE;
}
-
+
SetStepGuessedUnfolding(AliHFEcuts::kStepRecKineITSTPC + AliHFEcuts::kNcutStepsMCTrack);
-
+
AliCFDataGrid *dataGridAfterFirstSteps = 0x0;
+
//////////////////////////////////
// Subtract hadron background
/////////////////////////////////
dataGridAfterFirstSteps = dataspectrumaftersubstraction;
}
+ //////////////////////////////////
+ // Subtract Photonic background
+ /////////////////////////////////
+ AliCFDataGrid *dataspectrumafterphotonicsubstraction = 0x0;
+ if(subtractphotonic) {
+ dataspectrumafterphotonicsubstraction = SubtractPhotonicBackground();
+ dataGridAfterFirstSteps = dataspectrumafterphotonicsubstraction;
+ }
+
////////////////////////////////////////////////
// Correct for TPC efficiency from V0 if any
///////////////////////////////////////////////
AliCFContainer *dataContainerV0 = GetContainer(kDataContainerV0);
if(dataContainerV0){
dataspectrumafterV0efficiencycorrection = CorrectV0Efficiency(dataspectrumaftersubstraction);
- dataGridAfterFirstSteps = dataspectrumafterV0efficiencycorrection;
+ dataGridAfterFirstSteps = dataspectrumafterV0efficiencycorrection;
}
//////////////////////////////////////////////////////////////////////////////
dataGridAfterFirstSteps = dataspectrumafterefficiencyparametrizedcorrection;
}
- ///////////////
- // Unfold
- //////////////
- THnSparse *correctedspectrum = Unfold(dataGridAfterFirstSteps);
- if(!correctedspectrum){
- AliError("No corrected spectrum\n");
- return kFALSE;
+ TGraphErrors* correctedspectrumD = 0x0;
+ TGraphErrors* alltogetherspectrumD = 0x0;
+ if(fStepMC>fStepTrue) {
+ ///////////////
+ // Unfold
+ //////////////
+ THnSparse *correctedspectrum = Unfold(dataGridAfterFirstSteps);
+ if(!correctedspectrum){
+ AliError("No corrected spectrum\n");
+ return kFALSE;
+ }
+
+ /////////////////////
+ // Simply correct
+ ////////////////////
+ AliCFDataGrid *alltogetherCorrection = CorrectForEfficiency(dataGridAfterFirstSteps);
+
+ ////////////////////
+ // Normalization
+ ////////////////////
+ correctedspectrumD = Normalize(correctedspectrum);
+ alltogetherspectrumD = Normalize(alltogetherCorrection);
}
-
- /////////////////////
- // Simply correct
- ////////////////////
- AliCFDataGrid *alltogetherCorrection = CorrectForEfficiency(dataGridAfterFirstSteps);
+ else {
+ ////////////////////
+ // Normalization
+ ////////////////////
+ if(dataGridAfterFirstSteps) {
+ correctedspectrumD = Normalize(dataGridAfterFirstSteps);
+ alltogetherspectrumD = Normalize(dataGridAfterFirstSteps);
+ }
+ }
+
// QA final results
- TGraphErrors* correctedspectrumD = Normalize(correctedspectrum);
- TGraphErrors* alltogetherspectrumD = Normalize(alltogetherCorrection);
+
fQA->AddResultAt(correctedspectrumD,AliHFEInclusiveSpectrumQA::kFinalResultUnfolded);
fQA->AddResultAt(alltogetherspectrumD,AliHFEInclusiveSpectrumQA::kFinalResultDirectEfficiency);
fQA->DrawResult();
AliError("MC background container not found");
return NULL;
}
-
+
Int_t stepbackground = 1;
AliCFDataGrid *backgroundGrid = new AliCFDataGrid("ContaminationGrid","ContaminationGrid",*backgroundContainer,stepbackground);
// Subtract
spectrumSubtracted->Add(backgroundGrid,-1.0);
-
+
// QA
TH1D *subtractedspectrum = (TH1D *) spectrumSubtracted->Project(0);
- CorrectFromTheWidth(subtractedspectrum);
+ AliHFEtools::NormaliseBinWidth(subtractedspectrum);
TH1D *rawspectrum = (TH1D *) dataspectrumbeforesubstraction->Project(0);
- CorrectFromTheWidth(rawspectrum);
+ AliHFEtools::NormaliseBinWidth(rawspectrum);
fQA->AddResultAt(subtractedspectrum,AliHFEInclusiveSpectrumQA::kAfterSC);
fQA->AddResultAt(rawspectrum,AliHFEInclusiveSpectrumQA::kBeforeSC);
fQA->DrawSubtractContamination();
+ if(fNbDimensions>=2) {
+ fQA->AddResultAt((TObject *) spectrumSubtracted,AliHFEInclusiveSpectrumQA::kAfterSCND);
+ fQA->AddResultAt((TObject *) dataspectrumbeforesubstraction,AliHFEInclusiveSpectrumQA::kBeforeSCND);
+ fQA->AddResultAt((TObject *) backgroundGrid,AliHFEInclusiveSpectrumQA::kHadronContaminationND);
+ fQA->DrawSubtractContaminationND();
+ }
+
+
return spectrumSubtracted;
}
+//____________________________________________________________
+AliCFDataGrid* AliHFEInclusiveSpectrum::SubtractPhotonicBackground(){
+ //
+ // Apply Photonic background subtraction
+ //
+
+ printf("Photonic Background Subtraction \n");
+
+ // Raw spectrum
+ AliCFContainer *dataContainer = GetContainer(kDataContainer);
+ if(!dataContainer){
+ AliError("Data Container not available");
+ return NULL;
+ }
+ printf("Step data: %d\n",fStepData);
+ AliCFDataGrid *spectrumPhotonicSubtracted = new AliCFDataGrid("spectrumPhotonicSubtracted", "Data Grid for spectrum after Photonic Background subtraction", *dataContainer,fStepData);
+
+ AliCFDataGrid *dataSpectrumBeforePhotonicSubstraction = (AliCFDataGrid *) ((AliCFDataGrid *)GetSpectrum(GetContainer(kDataContainer),fStepData))->Clone();
+ dataSpectrumBeforePhotonicSubstraction->SetName("dataSpectrumBeforePhotonicSubstraction");
+
+
+ // Background Estimate
+ AliCFContainer *photonicContainer = GetContainer(kPhotonicBackground);
+ if(!photonicContainer){
+ AliError("Photonic background container not found");
+ return NULL;
+ }
+
+ Int_t stepbackground = 0;
+ AliCFDataGrid *photonicGrid = new AliCFDataGrid("ContaminationGrid","ContaminationGrid",*photonicContainer,stepbackground);
+
+ // Subtract
+ spectrumPhotonicSubtracted->Add(photonicGrid,-1.0);
+
+ // QA
+ TH1D *photonicsubtractedspectrum = (TH1D *) spectrumPhotonicSubtracted->Project(0);
+ AliHFEtools::NormaliseBinWidth(photonicsubtractedspectrum);
+ TH1D *newrawspectrum = (TH1D *) dataSpectrumBeforePhotonicSubstraction->Project(0);
+ AliHFEtools::NormaliseBinWidth(newrawspectrum);
+ fQA->AddResultAt(photonicsubtractedspectrum,AliHFEInclusiveSpectrumQA::kAfterSPB);
+ fQA->AddResultAt(newrawspectrum,AliHFEInclusiveSpectrumQA::kBeforeSPB);
+ fQA->DrawSubtractPhotonicBackground();
+
+ return spectrumPhotonicSubtracted;
+}
+
+
//____________________________________________________________
AliCFDataGrid *AliHFEInclusiveSpectrum::CorrectParametrizedEfficiency(AliCFDataGrid* const bgsubpectrum){
dataGrid = bgsubpectrum;
}
else {
-
+
AliCFContainer *dataContainer = GetContainer(kDataContainer);
if(!dataContainer){
AliError("Data Container not available");
ULong64_t nEntries = h->GetNbins();
for (ULong64_t i = 0; i < nEntries; ++i) {
-
+
Double_t value = h->GetBinContent(i, coord);
//Double_t valuecontainer = dataContainerbis->GetBinContent(coord,fStepData);
//printf("Value %f, and valuecontainer %f\n",value,valuecontainer);
-
+
// Get the bin co-ordinates given an coord
for (Int_t j = 0; j < nbdimensions; ++j)
points[j] = h->GetAxis(j)->GetBinCenter(coord[j]);
if(valueEfficiency > 0.0) {
h->SetBinContent(coord,value/valueEfficiency);
dataContainerbis->SetBinContent(coord,fStepData,value/valueEfficiency);
+ Double_t error = h->GetBinError(i);
+ h->SetBinError(coord,error/valueEfficiency);
+ dataContainerbis->SetBinError(coord,fStepData,error/valueEfficiency);
}
- Double_t error = h->GetBinError(i);
- h->SetBinError(coord,error/valueEfficiency);
- dataContainerbis->SetBinError(coord,fStepData,error/valueEfficiency);
-
}
// QA
TH1D *afterE = (TH1D *) resultt->Project(0);
- CorrectFromTheWidth(afterE);
+ AliHFEtools::NormaliseBinWidth(afterE);
TH1D *beforeE = (TH1D *) dataGrid->Project(0);
- CorrectFromTheWidth(beforeE);
+ AliHFEtools::NormaliseBinWidth(beforeE);
fQA->AddResultAt(afterE,AliHFEInclusiveSpectrumQA::kAfterPE);
fQA->AddResultAt(beforeE,AliHFEInclusiveSpectrumQA::kBeforePE);
fQA->AddResultAt(fEfficiencyFunction,AliHFEInclusiveSpectrumQA::kPEfficiency);
fQA->DrawCorrectWithEfficiency(AliHFEInclusiveSpectrumQA::kParametrized);
+
+ if(fNbDimensions>=2) {
+ fQA->AddResultAt((TObject *) resultt,AliHFEInclusiveSpectrumQA::kAfterPEND);
+ fQA->AddResultAt((TObject *) dataGrid,AliHFEInclusiveSpectrumQA::kBeforePEND);
+ fQA->AddResultAt((TObject *) fEfficiencyFunction,AliHFEInclusiveSpectrumQA::kPEfficiencyND);
+ fQA->DrawCorrectWithEfficiencyND(AliHFEInclusiveSpectrumQA::kParametrized);
+ }
return resultt;
// QA
TH1D *afterE = (TH1D *) result->Project(0);
- CorrectFromTheWidth(afterE);
+ AliHFEtools::NormaliseBinWidth(afterE);
TH1D *beforeE = (TH1D *) dataGrid->Project(0);
- CorrectFromTheWidth(beforeE);
+ AliHFEtools::NormaliseBinWidth(beforeE);
TH1D* efficiencyDproj = (TH1D *) efficiencyD->Project(0);
fQA->AddResultAt(afterE,AliHFEInclusiveSpectrumQA::kAfterV0);
fQA->AddResultAt(beforeE,AliHFEInclusiveSpectrumQA::kBeforeV0);
fQA->AddResultAt(efficiencyDproj,AliHFEInclusiveSpectrumQA::kV0Efficiency);
fQA->DrawCorrectWithEfficiency(AliHFEInclusiveSpectrumQA::kV0);
+
+ if(fNbDimensions>=2) {
+ fQA->AddResultAt((TObject *) result,AliHFEInclusiveSpectrumQA::kAfterV0ND);
+ fQA->AddResultAt((TObject *) dataGrid,AliHFEInclusiveSpectrumQA::kBeforeV0ND);
+ fQA->AddResultAt((TObject *) efficiencyD,AliHFEInclusiveSpectrumQA::kV0EfficiencyND);
+ fQA->DrawCorrectWithEfficiencyND(AliHFEInclusiveSpectrumQA::kV0);
+ }
return result;
}
// Data
- AliCFDataGrid *dataGrid = 0x0;
+ AliCFDataGrid *dataGrid = 0x0;
if(bgsubpectrum) {
dataGrid = bgsubpectrum;
}
}
dataGrid = new AliCFDataGrid("dataGrid","dataGrid",*dataContainer, fStepData);
- }
-
+ }
+
// Guessed
AliCFDataGrid* guessedGrid = new AliCFDataGrid("guessed","",*mcContainer, fStepGuessedUnfolding);
THnSparse* guessedTHnSparse = ((AliCFGridSparse*)guessedGrid->GetData())->GetGrid();
AliCFEffGrid* efficiencyD = new AliCFEffGrid("efficiency","",*mcContainer);
efficiencyD->CalculateEfficiency(fStepMC,fStepTrue);
- // Unfold
-
+ // Unfold
+
AliCFUnfolding unfolding("unfolding","",fNbDimensions,fCorrelation,efficiencyD->GetGrid(),dataGrid->GetGrid(),guessedTHnSparse,1.e-06,0,fNumberOfIterations);
if(fSetSmoothing) unfolding.UseSmoothing();
unfolding.Unfold();
// Results
THnSparse* result = unfolding.GetUnfolded();
THnSparse* residual = unfolding.GetEstMeasured();
-
+
// QA
TH1D *residualh = (TH1D *) residual->Projection(0);
TH1D *beforeE = (TH1D *) dataGrid->Project(0);
TH1D* efficiencyDproj = (TH1D *) efficiencyD->Project(0);
TH1D *afterE = (TH1D *) result->Projection(0);
- CorrectFromTheWidth(residualh);
- CorrectFromTheWidth(beforeE);
- CorrectFromTheWidth(afterE);
+ AliHFEtools::NormaliseBinWidth(residualh);
+ AliHFEtools::NormaliseBinWidth(beforeE);
+ AliHFEtools::NormaliseBinWidth(afterE);
fQA->AddResultAt(residualh,AliHFEInclusiveSpectrumQA::kResidualU);
fQA->AddResultAt(afterE,AliHFEInclusiveSpectrumQA::kAfterU);
fQA->AddResultAt(beforeE,AliHFEInclusiveSpectrumQA::kBeforeU);
}
//____________________________________________________________
AliCFDataGrid *AliHFEInclusiveSpectrum::CorrectForEfficiency(AliCFDataGrid* const bgsubpectrum){
-
+
//
// Apply unfolding and efficiency correction together to bgsubspectrum
//
efficiencyD->CalculateEfficiency(fStepMC,fStepTrue);
// Data in the right format
- AliCFDataGrid *dataGrid = 0x0;
+ AliCFDataGrid *dataGrid = 0x0;
if(bgsubpectrum) {
dataGrid = bgsubpectrum;
}
else {
-
+
AliCFContainer *dataContainer = GetContainer(kDataContainer);
if(!dataContainer){
AliError("Data Container not available");
}
dataGrid = new AliCFDataGrid("dataGrid","dataGrid",*dataContainer, fStepData);
- }
+ }
// Correct
AliCFDataGrid *result = (AliCFDataGrid *) dataGrid->Clone();
// QA
TH1D *afterE = (TH1D *) result->Project(0);
- CorrectFromTheWidth(afterE);
- TH1D *beforeE = (TH1D *) dataGrid->Project(0);
- CorrectFromTheWidth(beforeE);
+ AliHFEtools::NormaliseBinWidth(afterE);
+ TH1D *beforeE = (TH1D *) dataGrid->Project(0);
+ AliHFEtools::NormaliseBinWidth(beforeE);
TH1D* efficiencyDproj = (TH1D *) efficiencyD->Project(0);
fQA->AddResultAt(afterE,AliHFEInclusiveSpectrumQA::kAfterMCE);
fQA->AddResultAt(beforeE,AliHFEInclusiveSpectrumQA::kBeforeMCE);
fQA->AddResultAt(efficiencyDproj,AliHFEInclusiveSpectrumQA::kMCEfficiency);
fQA->DrawCorrectWithEfficiency(AliHFEInclusiveSpectrumQA::kMC);
-
+ if(fNbDimensions>=2) {
+ fQA->AddResultAt((TObject *) result,AliHFEInclusiveSpectrumQA::kAfterMCEND);
+ fQA->AddResultAt((TObject *) dataGrid,AliHFEInclusiveSpectrumQA::kBeforeMCEND);
+ fQA->AddResultAt((TObject *) efficiencyD,AliHFEInclusiveSpectrumQA::kMCEfficiencyND);
+ fQA->DrawCorrectWithEfficiencyND(AliHFEInclusiveSpectrumQA::kMC);
+ }
+
return result;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff