DGUARD(fDebug,3,"Make a centrality bin [%f,%f]: %s", low, high, name);
return new CentralityBin(name, low, high);
}
+
+#define TESTAPPEND(SCHEME,BIT,STRING) \
+ do { if (!(SCHEME & BIT)) break; \
+ if (!s.IsNull()) s.Append(","); s.Append(STRING); } while(false)
+
//________________________________________________________________________
-void
-AliBasedNdetaTask::SetNormalizationScheme(const char* what)
+const Char_t*
+AliBasedNdetaTask::NormalizationSchemeString(UShort_t scheme)
+{
+ // Create a string from normalization scheme bits
+ static TString s;
+ s = "";
+
+ if (scheme == kNone)
+ return s.Data();
+ if (scheme == kFull) {
+ s = "FULL";
+ return s.Data();
+ }
+ TESTAPPEND(scheme, kEventLevel, "EVENT");
+ TESTAPPEND(scheme, kShape, "SHAPE");
+ TESTAPPEND(scheme, kBackground, "BACKGROUND");
+ TESTAPPEND(scheme, kTriggerEfficiency, "TRIGGER");
+ TESTAPPEND(scheme, kZeroBin, "ZEROBIN");
+
+ return s.Data();
+}
+//________________________________________________________________________
+UShort_t
+AliBasedNdetaTask::ParseNormalizationScheme(const char* what)
{
- //
- // Set normalisation scheme
- //
- DGUARD(fDebug,3,"Set the normalization scheme: %s", what);
UShort_t scheme = 0;
TString twhat(what);
twhat.ToUpper();
else if (s.CompareTo("NONE") == 0) bit = kNone;
else if (s.CompareTo("ZEROBIN") == 0) bit = kZeroBin;
else
- Warning("SetNormalizationScheme", "Unknown option %s", s.Data());
+ ::Warning("SetNormalizationScheme", "Unknown option %s", s.Data());
if (add) scheme |= bit;
else scheme ^= bit;
}
- SetNormalizationScheme(scheme);
+ return scheme;
+}
+//________________________________________________________________________
+void
+AliBasedNdetaTask::SetNormalizationScheme(const char* what)
+{
+ //
+ // Set normalisation scheme
+ //
+ DGUARD(fDebug,3,"Set the normalization scheme: %s", what);
+ SetNormalizationScheme(ParseNormalizationScheme(what));
}
//________________________________________________________________________
void
{
DGUARD(fDebug,3,"Set the normalization scheme: 0x%x", scheme);
fNormalizationScheme = scheme;
- TString tit = "";
- if (scheme == kFull) tit = "FULL";
- else {
- if (scheme & kEventLevel) tit.Append("EVENT ");
- if (scheme & kShape) tit.Append("SHAPE ");
- if (scheme & kBackground) tit.Append("BACKGROUND ");
- if (scheme & kTriggerEfficiency) tit.Append("TRIGGER ");
- if (scheme & kZeroBin) tit.Append("ZEROBIN ");
- }
- tit = tit.Strip(TString::kBoth);
+#if 0
+ const Char_t* tit = NormalizationSchemeString(scheme);
if (!fSchemeString) fSchemeString = new TNamed("scheme", "");
fSchemeString->SetTitle(tit);
fSchemeString->SetUniqueID(fNormalizationScheme);
+#else
+ if (!fSchemeString)
+ fSchemeString = new TParameter<int>("scheme", scheme);
+ fSchemeString->SetUniqueID(fNormalizationScheme);
+#endif
}
//________________________________________________________________________
void
{
DGUARD(fDebug,3,"Set the trigger mask: 0x%0x", mask);
fTriggerMask = mask;
+#if 0
TString tit(AliAODForwardMult::GetTriggerString(mask));
tit = tit.Strip(TString::kBoth);
if (!fTriggerString) fTriggerString = new TNamed("trigger", "");
fTriggerString->SetTitle(tit);
fTriggerString->SetUniqueID(fTriggerMask);
+#else
+ if (!fTriggerString)
+ fTriggerString = new TParameter<int>("trigger", fTriggerMask);
+ fTriggerString->SetUniqueID(fTriggerMask);
+#endif
}
//________________________________________________________________________
}
// Here, we get the update
+#if 0
if (!fSNNString) {
UShort_t sNN = forward->GetSNN();
fSNNString = new TNamed("sNN", "");
// Print();
}
+#else
+ if (!fSNNString) {
+ UShort_t sNN = forward->GetSNN();
+ fSNNString = new TParameter<int>("sNN", sNN);
+ fSNNString->SetUniqueID(sNN);
+ fSums->Add(fSNNString);
+ UShort_t sys = forward->GetSystem();
+ fSysString = new TParameter<int>("sys", sys);
+ fSysString->SetUniqueID(sys);
+ fSums->Add(fSysString);
+
+ fSums->Add(fSchemeString);
+ fSums->Add(fTriggerString);
+
+ // Print();
+ }
+
+#endif
PostData(1, fSums);
}
fOutput->SetName(Form("%s_result", GetName()));
fOutput->SetOwner();
- fSNNString = static_cast<TNamed*>(fSums->FindObject("sNN"));
- fSysString = static_cast<TNamed*>(fSums->FindObject("sys"));
+ fSNNString = static_cast<TParameter<int>*>(fSums->FindObject("sNN"));
+ fSysString = static_cast<TParameter<int>*>(fSums->FindObject("sys"));
fCentAxis = static_cast<TAxis*>(fSums->FindObject("centAxis"));
- fSchemeString = static_cast<TNamed*>(fSums->FindObject("scheme"));
- fTriggerString = static_cast<TNamed*>(fSums->FindObject("trigger"));
+ fSchemeString = static_cast<TParameter<int>*>(fSums->FindObject("scheme"));
+ fTriggerString = static_cast<TParameter<int>*>(fSums->FindObject("trigger"));
if(fSysString && fSNNString &&
fSysString->GetUniqueID() == AliForwardUtil::kPP)
if (dndetaMCStackRebin) fOutput->Add(dndetaMCStackRebin);
// Output collision energy string
- if (fSNNString) fOutput->Add(fSNNString->Clone());
+ if (fSNNString) {
+ UShort_t sNN = fSNNString->GetUniqueID();
+ TNamed* sNNObj = new TNamed(fSNNString->GetName(),
+ AliForwardUtil::CenterOfMassEnergyString(sNN));
+ sNNObj->SetUniqueID(sNN);
+ fOutput->Add(sNNObj); // fSNNString->Clone());
+ }
// Output collision system string
- if (fSysString) fOutput->Add(fSysString->Clone());
+ if (fSysString) {
+ UShort_t sys = fSysString->GetUniqueID();
+ TNamed* sysObj = new TNamed(fSysString->GetName(),
+ AliForwardUtil::CollisionSystemString(sys));
+ sysObj->SetUniqueID(sys);
+ fOutput->Add(sysObj); // fSysString->Clone());
+ }
// Output centrality axis
if (fCentAxis) fOutput->Add(fCentAxis);
// Output trigger string
- if (fTriggerString) fOutput->Add(fTriggerString->Clone());
+ if (fTriggerString) {
+ UShort_t mask = fTriggerString->GetUniqueID();
+ TNamed* maskObj = new TNamed(fTriggerString->GetName(),
+ AliAODForwardMult::GetTriggerString(mask));
+ maskObj->SetUniqueID(mask);
+ fOutput->Add(maskObj); // fTriggerString->Clone());
+ }
// Normalization string
- if (fSchemeString) fOutput->Add(fSchemeString->Clone());
+ if (fSchemeString) {
+ UShort_t scheme = fSchemeString->GetUniqueID();
+ TNamed* schemeObj = new TNamed(fSchemeString->GetName(),
+ NormalizationSchemeString(scheme));
+ schemeObj->SetUniqueID(scheme);
+ fOutput->Add(schemeObj); // fSchemeString->Clone());
+ }
// Output vertex axis
TAxis* vtxAxis = new TAxis(1,fVtxMin,fVtxMax);
*
*/
#include <AliAnalysisTaskSE.h>
+#include <TParameter.h>
class TAxis;
class TList;
class TH2D;
* @param h Correction
*/
void SetShapeCorrection(const TH2F* h);
+ /**
+ * Get a string representing the normalization scheme
+ *
+ * @param scheme Normalization scheme bits
+ *
+ * @return String representation
+ */
+ static const Char_t* NormalizationSchemeString(UShort_t scheme);
+ /**
+ * Parse a string representing the normalization scheme
+ *
+ * @param what String of the normalization scheme
+ *
+ * @return normalization scheme bits
+ */
+ static UShort_t ParseNormalizationScheme(const Char_t* what);
/**
* Setthe normalisation scheme to use
*
Double_t fTriggerEff; // Trigger efficiency for selected trigger(s)
TH2F* fShapeCorr; // Shape correction
TObjArray* fListOfCentralities; // Centrality bins
+#if 0
TNamed* fSNNString; // sqrt(s_NN) string
TNamed* fSysString; // Collision system string
+#else
+ TParameter<int>* fSNNString; // sqrt(s_NN) string
+ TParameter<int>* fSysString; // Collision system string
+#endif
TH1D* fCent; // Centrality distribution
TAxis* fCentAxis; // Centrality axis
UShort_t fNormalizationScheme; // Normalization scheme
+#if 0
TNamed* fSchemeString; // Normalization scheme string
TNamed* fTriggerString; // Trigger string
+#else
+ TParameter<int>* fSchemeString; // Normalization scheme string
+ TParameter<int>* fTriggerString; // Trigger string
+#endif
TString fFinalMCCorrFile; //Filename for final MC corr
- ClassDef(AliBasedNdetaTask,6); // Determine multiplicity in base area
+ ClassDef(AliBasedNdetaTask,7); // Determine multiplicity in base area
};
#endif
DGUARD(fDebug, 2, "Cache maximum weights in FMD density calculator");
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
AliFMDCorrELossFit* cor = fcm.GetELossFit();
- TAxis eta(axis); // Set to default from parent task
+
+ TAxis eta(axis.GetNbins(),
+ axis.GetXmin(),
+ axis.GetXmax());
+
if(cor)
eta.Set(cor->GetEtaAxis().GetNbins(),
cor->GetEtaAxis().GetXmin(),
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* 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));
TParameter<int>* low = new TParameter<int>("lowFlux", fLowFluxCut);
TParameter<bool>* fpv = new TParameter<bool>("fpVtx",fUseFirstPhysicsVertex);
TParameter<bool>* v0a = new TParameter<bool>("v0and",fUseV0AND);
- TParameter<int>* ncp = new TParameter<int>("nPileUp", fMinPileupContrib);
-
+ TParameter<int>* nCp = new TParameter<int>("nPileUp", fMinPileupContrib);
+ TParameter<Double_t>* dP = new TParameter<Double_t>("dPileup",
+ fMinPileupDistance);
#endif
sys->SetUniqueID(fCollisionSystem);
sNN->SetUniqueID(fEnergy);
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(v0a);
fList->Add(nCp);
fList->Add(dP);
-
-
}
//____________________________________________________________________
// most-probably-value peak found from the energy distributions, minus
// 2 times the width of the corresponding Landau.
- TAxis eAxis(axis);
+ TAxis eAxis(axis.GetNbins(),
+ axis.GetXmin(),
+ axis.GetXmax());
if(fits)
eAxis.Set(fits->GetEtaAxis().GetNbins(),
fits->GetEtaAxis().GetXmin(),
fMCRingSums.Get(3, 'I')->SetMarkerColor(AliForwardUtil::RingColor(3, 'I'));
fMCRingSums.Get(3, 'O')->SetMarkerColor(AliForwardUtil::RingColor(3, 'O'));
-
-
fEventInspector.Init(*pv);
fSharingFilter.Init(*pe);
fDensityCalculator.Init(*pe);
fEventInspector.Init(*pv);
fEnergyFitter.Init(*pe);
- fSharingFilter.Init();
+ fSharingFilter.Init(*pe);
fDensityCalculator.Init(*pe);
this->Print();
// Production mode - not used here
// plugin->SetProductionMode();
+ // Do not test copying
+ plugin->SetCheckCopy(false);
+
// Set output to be per run
plugin->SetOutputToRunNo(true);
if (!fArg.IsNull()) arg.Append(Form("=%s", fArg.Data()));
o << " " << (prefix ? prefix : "")
<< std::left << std::setw(30) << arg
- << " " << fDesc << std::endl;
+ << " " << std::setw(30) << fDesc
+ << " [" << std::right << fValue << "]" << std::endl;
}
/**
* Print the setting
void PrintHelp(std::ostream& out, const char* prefix="") const
{
Option** ptr = fOptions;
+ if (fTrain) fTrain->SetOptionDefaults(const_cast<Runner&>(*this));
while (*ptr) {
(*ptr)->PrintHelp(out, prefix);
ptr++;
r.Add(new Option("per-run", "Per run merge"));
}
//------------------------------------------------------------------
+ /**
+ * Set the option values on the train. Sub-classes can overload
+ * this to set custom options on the train.
+ */
+ virtual void SetOptionDefaults(Runner& r)
+ {
+ Option* debug = r.FindOption("debug");
+ Option* date = r.FindOption("date");
+ Option* cluster = r.FindOption("cluster");
+ Option* dataSet = r.FindOption("dataSet");
+ Option* dataDir = r.FindOption("dataDir");
+ Option* pattern = r.FindOption("pattern");
+ Option* par = r.FindOption("par");
+ Option* type = r.FindOption("type");
+ Option* mode = r.FindOption("mode");
+ Option* oper = r.FindOption("oper");
+ Option* mc = r.FindOption("mc");
+ Option* verb = r.FindOption("verb");
+ Option* root = r.FindOption("root");
+ Option* aliroot = r.FindOption("aliroot");
+ Option* alien = r.FindOption("alien");
+ Option* overwrite = r.FindOption("overwrite");
+ Option* run_merge = r.FindOption("per-run");
+
+ if (date && !date->IsSet()) date->fValue = fDatime.AsString();
+ if (cluster && !cluster->IsSet()) cluster->fValue = fProofServer;
+ if (dataSet && !dataSet->IsSet()) dataSet->fValue = fDataSet;
+ if (dataDir && !dataDir->IsSet()) dataDir->fValue = fDataSet;
+ if (pattern && !pattern->IsSet()) pattern->fValue = fDataPattern;
+ if (debug && !debug->IsSet()) debug->fValue = fUseGDB ? "1" : "";
+ if (type && !type->IsSet()) type->fValue = TypeString(fExecType);
+ if (mode && !mode->IsSet()) mode->fValue = ModeString(fExecMode);
+ if (oper && !oper->IsSet()) oper->fValue = OperString(fExecOper);
+ if (par && !par->IsSet()) par->fValue = fUsePar ? "1" : "";
+ if (mc && !mc->IsSet()) mc->fValue = fMC ? "1" : "";
+ if (verb && !verb->IsSet()) verb->fValue = Form("%d", fVerbose);
+ if (root && !root->IsSet()) root->fValue = fRootVersion;
+ if (aliroot && !aliroot->IsSet()) aliroot->fValue = fAliRootVersion;
+ if (alien && !alien->IsSet()) alien->fValue = fAliEnAPIVersion;
+ if (overwrite && !overwrite->IsSet())
+ overwrite->fValue = fAllowOverwrite ? "1" : "";
+ if (run_merge && !run_merge->IsSet())
+ run_merge->fValue = fPerRunMerge ? "1" : "";
+ }
/**
* Set the option values on the train. Sub-classes can overload
* this to set custom options on the train.