#include <TArrayI.h>
#include <TArrayF.h>
#include <TLinearFitter.h>
+#include <TSystem.h>
+#include <TMD5.h>
#include <AliVEvent.h>
#include <AliVTrack.h>
fMCperiodTPC(),
fMCperiodUser(),
fCurrentFile(),
+fCurrentAliRootRev(-1),
fRecoPass(0),
fRecoPassUser(-1),
fRun(-1),
fArrPidResponseMaster(NULL),
fResolutionCorrection(NULL),
fOADBvoltageMaps(NULL),
-fUseTPCEtaCorrection(kFALSE),//TODO: In future, default kTRUE
+fUseTPCEtaCorrection(kFALSE),
+fUseTPCMultiplicityCorrection(kFALSE),
fTRDPIDResponseObject(NULL),
-fTOFtail(1.1),
+fTOFtail(0.9),
fTOFPIDParams(NULL),
fHMPIDPIDParams(NULL),
fEMCALPIDParams(NULL),
fMCperiodTPC(),
fMCperiodUser(other.fMCperiodUser),
fCurrentFile(),
+fCurrentAliRootRev(other.fCurrentAliRootRev),
fRecoPass(0),
fRecoPassUser(other.fRecoPassUser),
fRun(-1),
fResolutionCorrection(NULL),
fOADBvoltageMaps(NULL),
fUseTPCEtaCorrection(other.fUseTPCEtaCorrection),
+fUseTPCMultiplicityCorrection(other.fUseTPCMultiplicityCorrection),
fTRDPIDResponseObject(NULL),
-fTOFtail(1.1),
+fTOFtail(0.9),
fTOFPIDParams(NULL),
fHMPIDPIDParams(NULL),
fEMCALPIDParams(NULL),
fMCperiodTPC="";
fMCperiodUser=other.fMCperiodUser;
fCurrentFile="";
+ fCurrentAliRootRev=other.fCurrentAliRootRev;
fRecoPass=0;
fRecoPassUser=other.fRecoPassUser;
fRun=-1;
fResolutionCorrection=NULL;
fOADBvoltageMaps=NULL;
fUseTPCEtaCorrection=other.fUseTPCEtaCorrection;
+ fUseTPCMultiplicityCorrection=other.fUseTPCMultiplicityCorrection;
fTRDPIDResponseObject=NULL;
fEMCALPIDParams=NULL;
- fTOFtail=1.1;
+ fTOFtail=0.9;
fTOFPIDParams=NULL;
fHMPIDPIDParams=NULL;
fCurrentEvent=other.fCurrentEvent;
+
}
return *this;
}
//get number of sigmas according the selected TPC gain configuration scenario
const AliVTrack *track=static_cast<const AliVTrack*>(vtrack);
-// return 0.;
- Float_t nSigma=fTPCResponse.GetNumberOfSigmas(track, type, dedxSource, fUseTPCEtaCorrection);
+ Float_t nSigma=fTPCResponse.GetNumberOfSigmas(track, type, dedxSource, fUseTPCEtaCorrection, fUseTPCMultiplicityCorrection);
return nSigma;
}
fTPCResponse.SetSigma(3.79301e-03*corrSigma, 2.21280e+04);
}
+ // Set up TPC multiplicity for PbPb
+ //TODO Will NOT give the desired number for AODs -> Needs new variable/function in future.
+ // Fatal, if AOD event and correction enabled
+ //printf("DETECTED class: %s (%d)\n\n\n\n", event->IsA()->GetName(), fUseTPCMultiplicityCorrection);//TODO
+ if (fUseTPCMultiplicityCorrection && strcmp(event->IsA()->GetName(), "AliESDEvent") != 0) {
+ AliFatal("TPC multiplicity correction is enabled, but will NOT work for AOD events, only for ESD => Disabled multiplicity correction!");
+ fUseTPCMultiplicityCorrection = kFALSE;
+ }
+
+ if (fUseTPCMultiplicityCorrection)
+ fTPCResponse.SetCurrentEventMultiplicity(event->GetNumberOfTracks());
+ else
+ fTPCResponse.SetCurrentEventMultiplicity(0);
+
//TOF resolution
SetTOFResponse(event, (AliPIDResponse::EStartTimeType_t)fTOFPIDParams->GetStartTimeMethod());
else{
fCurrCentrality = -1;
}
+
+ // Set centrality percentile for EMCAL
+ fEMCALResponse.SetCentrality(fCurrCentrality);
+
}
//______________________________________________________________________________
fBeamType="";
fBeamType="PP";
+
+ Bool_t hasProdInfo=(fCurrentFile.BeginsWith("LHC"));
- TPRegexp reg(".*(LHC1[1-2][a-z]+[0-9]+[a-z_]*)/.*");
+ TPRegexp reg(".*(LHC1[1-3][a-z]+[0-9]+[a-z_]*)/.*");
+ if (hasProdInfo) reg=TPRegexp("LHC1[1-2][a-z]+[0-9]+[a-z_]*");
TPRegexp reg12a17("LHC1[2-3][a-z]");
//find the period by run number (UGLY, but not stored in ESD and AOD... )
fLHCperiod="LHC10H";
fMCperiodTPC="LHC10H8";
if (reg.MatchB(fCurrentFile)) fMCperiodTPC="LHC11A10";
+ // exception for 13d2 and later
+ if (fCurrentAliRootRev >= 62714) fMCperiodTPC="LHC13D2";
fBeamType="PBPB";
}
else if (fRun>=139847&&fRun<=146974) { fLHCperiod="LHC11A"; fMCperiodTPC="LHC10F6A"; }
// if (fRun >= 188167 && fRun <= 188355 ) { fLHCperiod="LHC12G"; fBeamType="PP"; /*fMCperiodTPC="";*/ }
// if (fRun >= 188356 && fRun <= 188503 ) { fLHCperiod="LHC12G"; fBeamType="PPB"; /*fMCperiodTPC="";*/ }
// for the moment use 12g parametrisation for all full gain runs (LHC12f+)
- if (fRun >= 186636 && fRun < 194480) { fLHCperiod="LHC12G"; fBeamType="PPB"; fMCperiodTPC="LHC12G"; }
- if (fRun >= 194480) { fLHCperiod="LHC13B"; fBeamType="PPB"; fMCperiodTPC="LHC12G"; }
+ if (fRun >= 186636 && fRun < 194480) { fLHCperiod="LHC12G"; fBeamType="PPB"; fMCperiodTPC="LHC12G"; }
+
+ // New parametrisation for 2013 pPb runs
+ if (fRun >= 194480) {
+ fLHCperiod="LHC13B";
+ fBeamType="PPB";
+ fMCperiodTPC="LHC12G";
+
+ if (fCurrentAliRootRev >= 61605)
+ fMCperiodTPC="LHC13B2_FIX";
+ if (fCurrentAliRootRev >= 62714)
+ fMCperiodTPC="LHC13B2_FIXn1";
+ }
//exception new pp MC productions from 2011
if (fBeamType=="PP" && reg.MatchB(fCurrentFile)) { fMCperiodTPC="LHC11B2"; fBeamType="PP"; }
// exception for 11f1
- if (fCurrentFile.Contains("LHC11f1/")) fMCperiodTPC="LHC11F1";
+ if (fCurrentFile.Contains("LHC11f1")) fMCperiodTPC="LHC11F1";
// exception for 12f1a, 12f1b and 12i3
- if (fCurrentFile.Contains("LHC12f1a/") || fCurrentFile.Contains("LHC12f1b/")
- || fCurrentFile.Contains("LHC12i3/")) fMCperiodTPC="LHC12F1";
+ if (fCurrentFile.Contains("LHC12f1") || fCurrentFile.Contains("LHC12i3")) fMCperiodTPC="LHC12F1";
// exception for 12c4
- if (fCurrentFile.Contains("LHC12c4/")) fMCperiodTPC="LHC12C4";
+ if (fCurrentFile.Contains("LHC12c4")) fMCperiodTPC="LHC12C4";
}
//______________________________________________________________________________
TString period = fLHCperiod.IsNull() ? "No period information" : fLHCperiod;
if (fIsMC) {
- if (!fTuneMConData) {
+ if (!(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))) {
period=fMCperiodTPC;
dataType="MC";
}
fRecoPass = 1;
- if (!fTuneMConData && fMCperiodTPC.IsNull()) {
+ if (!(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC)) && fMCperiodTPC.IsNull()) {
AliFatal("MC detected, but no MC period set -> Not changing eta maps!");
return;
}
Form("TPCetaMaps_%s_pass%d", dataType.Data(), recopass));
if (statusCont) {
AliError("Failed initializing TPC eta correction maps from OADB -> Disabled eta correction");
+ fUseTPCEtaCorrection = kFALSE;
}
else {
AliInfo(Form("Loading TPC eta correction map from %s/COMMON/PID/data/TPCetaMaps.root", fOADBPath.Data()));
TH2D* etaMap = 0x0;
- if (fIsMC && !fTuneMConData) {
+ if (fIsMC && !(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))) {
TString searchMap = Form("TPCetaMaps_%s_%s_pass%d", dataType.Data(), period.Data(), recopass);
etaMap = dynamic_cast<TH2D *>(etaMapsCont.GetDefaultObject(searchMap.Data()));
if (!etaMap) {
if (!etaMap) {
AliError(Form("TPC eta correction map not found for run %d and also no default map found -> Disabled eta correction!!!", fRun));
+ fUseTPCEtaCorrection = kFALSE;
}
else {
TH2D* etaMapRefined = RefineHistoViaLinearInterpolation(etaMap, refineFactorMapX, refineFactorMapY);
if (!fTPCResponse.SetEtaCorrMap(etaMapRefined)) {
AliError(Form("Failed to set TPC eta correction map for run %d -> Disabled eta correction!!!", fRun));
fTPCResponse.SetEtaCorrMap(0x0);
+ fUseTPCEtaCorrection = kFALSE;
}
else {
- AliInfo(Form("Loaded TPC eta correction map (refine factors %.2f/%.2f) from %s/COMMON/PID/data/TPCetaMaps.root: %s",
- refineFactorMapX, refineFactorMapY, fOADBPath.Data(), fTPCResponse.GetEtaCorrMap()->GetTitle()));
+ AliInfo(Form("Loaded TPC eta correction map (refine factors %.2f/%.2f) from %s/COMMON/PID/data/TPCetaMaps.root: %s (MD5(map) = %s)",
+ refineFactorMapX, refineFactorMapY, fOADBPath.Data(), fTPCResponse.GetEtaCorrMap()->GetTitle(),
+ GetChecksum(fTPCResponse.GetEtaCorrMap()).Data()));
}
delete etaMapRefined;
}
else {
AliError(Form("Failed to set TPC eta correction map for run %d (map was loaded, but couldn't be refined) -> Disabled eta correction!!!", fRun));
+ fUseTPCEtaCorrection = kFALSE;
}
}
}
+ // If there was some problem loading the eta maps, it makes no sense to load the sigma maps (that require eta corrected data)
+ if (fUseTPCEtaCorrection == kFALSE) {
+ AliError("Failed to load TPC eta correction map required by sigma maps -> Using old parametrisation for sigma");
+ return;
+ }
+
// Load the sigma parametrisation (1/dEdx vs tanTheta_local (~eta))
AliOADBContainer etaSigmaMapsCont(Form("TPCetaSigmaMaps_%s_pass%d", dataType.Data(), recopass));
TObjArray* etaSigmaPars = 0x0;
- if (fIsMC && !fTuneMConData) {
+ if (fIsMC && !(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))) {
TString searchMap = Form("TPCetaSigmaMaps_%s_%s_pass%d", dataType.Data(), period.Data(), recopass);
etaSigmaPars = dynamic_cast<TObjArray *>(etaSigmaMapsCont.GetDefaultObject(searchMap.Data()));
if (!etaSigmaPars) {
fTPCResponse.SetSigmaParams(0x0, 0);
}
else {
- AliInfo(Form("Loaded TPC sigma correction map (refine factors %.2f/%.2f) from %s/COMMON/PID/data/TPCetaMaps.root: %s",
- refineFactorSigmaMapX, refineFactorSigmaMapY, fOADBPath.Data(), fTPCResponse.GetSigmaPar1Map()->GetTitle()));
+ AliInfo(Form("Loaded TPC sigma correction map (refine factors %.2f/%.2f) from %s/COMMON/PID/data/TPCetaMaps.root: %s (MD5(map) = %s, sigmaPar0 = %f)",
+ refineFactorSigmaMapX, refineFactorSigmaMapY, fOADBPath.Data(), fTPCResponse.GetSigmaPar1Map()->GetTitle(),
+ GetChecksum(fTPCResponse.GetSigmaPar1Map()).Data(), sigmaPar0));
}
delete etaSigmaPar1MapRefined;
TString datatype="DATA";
//in case of mc fRecoPass is per default 1
if (fIsMC) {
- if(!fTuneMConData) datatype="MC";
+ if(!(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))) datatype="MC";
fRecoPass=1;
}
// period
TString period=fLHCperiod;
- if (fIsMC && !fTuneMConData) period=fMCperiodTPC;
+ if (fIsMC && !(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))) period=fMCperiodTPC;
Int_t recopass = fRecoPass;
- if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) recopass = fRecoPassUser;
+ if(fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC)) recopass = fRecoPassUser;
AliInfo(Form("Searching splines for: %s %s PASS%d %s",datatype.Data(),period.Data(),recopass,fBeamType.Data()));
Bool_t found=kFALSE;
(AliPID::EParticleType)ispec,
(AliTPCPIDResponse::ETPCgainScenario)igainScenario );
fTPCResponse.SetUseDatabase(kTRUE);
- AliInfo(Form("Adding graph: %d %d - %s",ispec,igainScenario,responseFunction->GetName()));
+ AliInfo(Form("Adding graph: %d %d - %s (MD5(spline) = %s)",ispec,igainScenario,responseFunction->GetName(),
+ GetChecksum((TSpline3*)responseFunction).Data()));
found=kTRUE;
break;
}
(AliPID::EParticleType)ispec,
(AliTPCPIDResponse::ETPCgainScenario)igainScenario );
fTPCResponse.SetUseDatabase(kTRUE);
- AliInfo(Form("Adding graph: %d %d - %s",ispec,igainScenario,responseFunctionPion->GetName()));
+ AliInfo(Form("Adding graph: %d %d - %s (MD5(spline) = %s)",ispec,igainScenario,responseFunctionPion->GetName(),
+ GetChecksum((TSpline3*)responseFunctionPion).Data()));
found=kTRUE;
}
else if (grAll) {
(AliPID::EParticleType)ispec,
(AliTPCPIDResponse::ETPCgainScenario)igainScenario );
fTPCResponse.SetUseDatabase(kTRUE);
- AliInfo(Form("Adding graph: %d %d - %s",ispec,igainScenario,grAll->GetName()));
+ AliInfo(Form("Adding graph: %d %d - %s (MD5(spline) = %s)",ispec,igainScenario,grAll->GetName(),
+ GetChecksum((TSpline3*)grAll).Data()));
found=kTRUE;
}
//else
(AliPID::EParticleType)ispec,
(AliTPCPIDResponse::ETPCgainScenario)igainScenario );
fTPCResponse.SetUseDatabase(kTRUE);
- AliInfo(Form("Adding graph: %d %d - %s",ispec,igainScenario,responseFunctionProton->GetName()));
+ AliInfo(Form("Adding graph: %d %d - %s (MD5(spline) = %s)",ispec,igainScenario,responseFunctionProton->GetName(),
+ GetChecksum((TSpline3*)responseFunctionProton).Data()));
found=kTRUE;
}
else if (grAll) {
(AliPID::EParticleType)ispec,
(AliTPCPIDResponse::ETPCgainScenario)igainScenario );
fTPCResponse.SetUseDatabase(kTRUE);
- AliInfo(Form("Adding graph: %d %d - %s",ispec,igainScenario,grAll->GetName()));
+ AliInfo(Form("Adding graph: %d %d - %s (MD5(spline) = %s)",ispec,igainScenario,grAll->GetName(),
+ GetChecksum((TSpline3*)grAll).Data()));
found=kTRUE;
}
//else
AliError(Form("No splines found for: %s %s PASS%d %s",datatype.Data(),period.Data(),recopass,fBeamType.Data()));
}
+
//
- // Setup resolution parametrisation
+ // Setup multiplicity correction
+ //
+ if (fUseTPCMultiplicityCorrection && !(fBeamType.CompareTo("PP") == 0)) {
+ AliInfo("Multiplicity correction enabled!");
+
+ //TODO After testing, load parameters from outside
+ /*TODO now correction for MC
+ if (period.Contains("LHC11A10")) {//LHC11A10A
+ AliInfo("Using multiplicity correction parameters for 11a10!");
+ fTPCResponse.SetParameterMultiplicityCorrection(0, 6.90133e-06);
+ fTPCResponse.SetParameterMultiplicityCorrection(1, -1.22123e-03);
+ fTPCResponse.SetParameterMultiplicityCorrection(2, 1.80220e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(3, 0.1);
+ fTPCResponse.SetParameterMultiplicityCorrection(4, 6.45306e-03);
+
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(0, -2.85505e-07);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(1, -1.31911e-06);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(2, -0.5);
+
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(0, -4.29665e-05);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(1, 1.37023e-02);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(2, -6.36337e-01);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(3, 1.13479e-02);
+ }
+ else*/ if (period.Contains("LHC13B") || period.Contains("LHC13C") || period.Contains("LHC13D") || period.Contains("LHC13E") ||
+ period.Contains("LHC13F")) {// 2013 pPb data taking
+ AliInfo("Using multiplicity correction parameters for 13b.pass2!");
+
+ fTPCResponse.SetParameterMultiplicityCorrection(0, -5.906e-06);
+ fTPCResponse.SetParameterMultiplicityCorrection(1, -5.064e-04);
+ fTPCResponse.SetParameterMultiplicityCorrection(2, -3.521e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(3, 2.469e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(4, 0);
+
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(0, -5.32e-06);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(1, 1.177e-05);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(2, -0.5);
+
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(0, 0.);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(1, 0.);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(2, 0.);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(3, 0.);
+
+ /* Not too bad, but far from perfect in the details
+ fTPCResponse.SetParameterMultiplicityCorrection(0, -6.27187e-06);
+ fTPCResponse.SetParameterMultiplicityCorrection(1, -4.60649e-04);
+ fTPCResponse.SetParameterMultiplicityCorrection(2, -4.26450e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(3, 2.40590e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(4, 0);
+
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(0, -5.338e-06);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(1, 1.220e-05);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(2, -0.5);
+
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(0, 7.89237e-05);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(1, -1.30662e-02);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(2, 8.91548e-01);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(3, 1.47931e-02);
+ */
+ }
+ else if (period.Contains("LHC10H") && recopass == 2) {
+ AliInfo("Using multiplicity correction parameters for 10h.pass2!");
+ fTPCResponse.SetParameterMultiplicityCorrection(0, 3.21636e-07);
+ fTPCResponse.SetParameterMultiplicityCorrection(1, -6.65876e-04);
+ fTPCResponse.SetParameterMultiplicityCorrection(2, 1.28786e-03);
+ fTPCResponse.SetParameterMultiplicityCorrection(3, 1.47677e-02);
+ fTPCResponse.SetParameterMultiplicityCorrection(4, 0);
+
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(0, 7.23591e-08);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(1, 2.7469e-06);
+ fTPCResponse.SetParameterMultiplicityCorrectionTanTheta(2, -0.5);
+
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(0, -1.22590e-05);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(1, 6.88888e-03);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(2, -3.20788e-01);
+ fTPCResponse.SetParameterMultiplicitySigmaCorrection(3, 1.07345e-02);
+ }
+ else {
+ AliError(Form("Multiplicity correction is enabled, but no multiplicity correction parameters have been found for period %s.pass%d -> Mulitplicity correction DISABLED!", period.Data(), recopass));
+ fUseTPCMultiplicityCorrection = kFALSE;
+ fTPCResponse.ResetMultiplicityCorrectionFunctions();
+ }
+ }
+ else {
+ // Just set parameters such that overall correction factor is 1, i.e. no correction.
+ // This is just a reasonable choice for the parameters for safety reasons. Disabling
+ // the multiplicity correction will anyhow skip the calculation of the corresponding
+ // correction factor inside THIS class. Nevertheless, experts can access the TPCPIDResponse
+ // directly and use it for calculations - which should still give valid results, even if
+ // the multiplicity correction is explicitely enabled in such expert calls.
+
+ AliInfo(Form("Multiplicity correction %sdisabled (%s)!", fUseTPCMultiplicityCorrection ? "automatically " : "",
+ fUseTPCMultiplicityCorrection ? "pp collisions" : "requested by user"));
+
+ fUseTPCMultiplicityCorrection = kFALSE;
+ fTPCResponse.ResetMultiplicityCorrectionFunctions();
+ }
+
+ /*
+ //TODO NOW start
+ for (Int_t i = 0; i <= 4 + 1; i++) {
+ printf("parMultCorr: %d, %e\n", i, fTPCResponse.GetMultiplicityCorrectionFunction()->GetParameter(i));
+ }
+ for (Int_t j = 0; j <= 2 + 1; j++) {
+ printf("parMultCorrTanTheta: %d, %e\n", j, fTPCResponse.GetMultiplicityCorrectionFunctionTanTheta()->GetParameter(j));
+ }
+ for (Int_t j = 0; j <= 3 + 1; j++) {
+ printf("parMultSigmaCorr: %d, %e\n", j, fTPCResponse.GetMultiplicitySigmaCorrectionFunction()->GetParameter(j));
+ }
+
+ //TODO NOW end
+ */
+
+ //
+ // Setup old resolution parametrisation
//
//default
if (fArrPidResponseMaster)
fResolutionCorrection=(TF1*)fArrPidResponseMaster->FindObject(Form("TF1_%s_ALL_%s_PASS%d_%s_SIGMA",datatype.Data(),period.Data(),recopass,fBeamType.Data()));
- if (fResolutionCorrection) AliInfo(Form("Setting multiplicity correction function: %s",fResolutionCorrection->GetName()));
+ if (fResolutionCorrection) AliInfo(Form("Setting multiplicity correction function: %s (MD5(corr function) = %s)",
+ fResolutionCorrection->GetName(), GetChecksum(fResolutionCorrection).Data()));
//read in the voltage map
TVectorF* gsm = 0x0;
//______________________________________________________________________________
void AliPIDResponse::SetTRDSlices(UInt_t TRDslicesForPID[2],AliTRDPIDResponse::ETRDPIDMethod method) const{
- if(fLHCperiod == "LHC10d" || fLHCperiod == "LHC10e"){
+ if(fLHCperiod.Contains("LHC10D") || fLHCperiod.Contains("LHC10E")){
// backward compatibility for setting with 8 slices
TRDslicesForPID[0] = 0;
TRDslicesForPID[1] = 7;
// the following call is needed in order to fill the transient data member
// fTPCsignalTuned which is used in the TPCPIDResponse to judge
// if using tuned on data
- if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) this->GetTPCsignalTunedOnData(track);
+ if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))
+ this->GetTPCsignalTunedOnData(track);
- return fTPCResponse.GetNumberOfSigmas(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
+ return fTPCResponse.GetNumberOfSigmas(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, fUseTPCMultiplicityCorrection);
}
//______________________________________________________________________________
// the following call is needed in order to fill the transient data member
// fTPCsignalTuned which is used in the TPCPIDResponse to judge
// if using tuned on data
- if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) )
+ if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC))
this->GetTPCsignalTunedOnData(track);
- val=fTPCResponse.GetSignalDelta(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, ratio);
+ val=fTPCResponse.GetSignalDelta(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, fUseTPCMultiplicityCorrection, ratio);
return GetTPCPIDStatus(track);
}
//
AliVTrack *track=(AliVTrack*)vtrack;
val=GetSignalDeltaTOFold(track, type, ratio);
+
return GetTOFPIDStatus(track);
}
Double_t dedx=track->GetTPCsignal();
Bool_t mismatch=kTRUE/*, heavy=kTRUE*/;
- if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC) ) dedx = this->GetTPCsignalTunedOnData(track);
+ if (fTuneMConData && ((fTuneMConDataMask & kDetTPC) == kDetTPC)) dedx = this->GetTPCsignalTunedOnData(track);
Double_t bethe = 0.;
Double_t sigma = 0.;
for (Int_t j=0; j<nSpecies; j++) {
AliPID::EParticleType type=AliPID::EParticleType(j);
- bethe=fTPCResponse.GetExpectedSignal(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
- sigma=fTPCResponse.GetExpectedSigma(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection);
+ bethe=fTPCResponse.GetExpectedSignal(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, fUseTPCMultiplicityCorrection);
+ sigma=fTPCResponse.GetExpectedSigma(track, type, AliTPCPIDResponse::kdEdxDefault, fUseTPCEtaCorrection, fUseTPCMultiplicityCorrection);
if (TMath::Abs(dedx-bethe) > fRange*sigma) {
p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
const EDetPidStatus pidStatus=GetTOFPIDStatus(track);
if (pidStatus!=kDetPidOk) return pidStatus;
- const Double_t meanCorrFactor = 0.11/fTOFtail; // Correction factor on the mean because of the tail (should be ~ 0.1 with tail = 1.1)
+ const Double_t meanCorrFactor = 0.07/fTOFtail; // Correction factor on the mean because of the tail (should be ~ 0.1 with tail = 1.1)
for (Int_t j=0; j<nSpecies; j++) {
AliPID::EParticleType type=AliPID::EParticleType(j);
return kDetNoSignal;
}
+
+//______________________________________________________________________________
+TString AliPIDResponse::GetChecksum(const TObject* obj) const
+{
+ // Return the checksum for an object obj (tested to work properly at least for histograms and TSplines).
+
+ TString fileName = Form("tempChecksum.C"); // File name must be fixed for data type "TSpline3", since the file name will end up in the file content!
+
+ // For parallel processing, a unique file pathname is required. Uniqueness can be guaranteed by using a unique directory name
+ UInt_t index = 0;
+ TString uniquePathName = Form("tempChecksum_%u", index);
+
+ // To get a unique path name, increase the index until no directory
+ // of such a name exists.
+ // NOTE: gSystem->AccessPathName(...) returns kTRUE, if the access FAILED!
+ while (!gSystem->AccessPathName(uniquePathName.Data()))
+ uniquePathName = Form("tempChecksum_%u", ++index);
+
+ if (gSystem->mkdir(uniquePathName.Data()) < 0) {
+ AliError("Could not create temporary directory to store temp file for checksum determination!");
+ return "ERROR";
+ }
+
+ TString option = "";
+
+ // Save object as a macro, which will be deleted immediately after the checksum has been computed
+ // (does not work for desired data types if saved as *.root for some reason) - one only wants to compare the content, not
+ // the modification time etc. ...
+ if (dynamic_cast<const TH1*>(obj))
+ option = "colz"; // Histos need this option, since w/o this option, a counter is added to the filename
+
+
+ // SaveAs must be called with the fixed fileName only, since the first argument goes into the file content
+ // for some object types. Thus, change the directory, save the file and then go back
+ TString oldDir = gSystem->pwd();
+ gSystem->cd(uniquePathName.Data());
+ obj->SaveAs(fileName.Data(), option.Data());
+ gSystem->cd(oldDir.Data());
+
+ // Use the file to calculate the MD5 checksum
+ TMD5* md5 = TMD5::FileChecksum(Form("%s/%s", uniquePathName.Data(), fileName.Data()));
+ TString checksum = md5->AsString();
+
+ // Clean up
+ delete md5;
+ gSystem->Exec(Form("rm -rf %s", uniquePathName.Data()));
+
+ return checksum;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff