Fixed some compilation problems.
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 10:32:27 +0000 (10:32 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 10:32:27 +0000 (10:32 +0000)
Switch to using TParameter<T> (from TNamed) for storing parameters of the
analysis, as these can be merged.   Previoulsy, we used TNamed objects,
but since these cannot be merged, the stupid file merger writes copies
of every single object to the merged file and thereby slowing down
everything.  It would be good if the merger could be fixed - perhaps by
allowing a plug-in for merging a specific class of objects - e.g.,

  class TObjectMerger
  {
  public:
    virtual TObject* Merge(TObject* existing, TList* list);
    virtual TObject* Merge(TObject* existing, TObject* next);
  };
  TObject*
  TObjectMerger::Merge(TObject* existing, TList* list)
  {
    TMergeInfo info(existing);
    TClass* cl = existing->Class();
    ROOT::MergeFunc_t f = cl->GetMerge();
    if (f)
      f(existing, list, &info);
    return existing;
  }

  TNamedMerger : public TObjectMerger
  {
    TObject* Merge(TObject* e, TList* l)
    {
      TString tit(e->GetTitle());
      TIter next(l);
      TObject* o = 0;
      while ((o = next())) {
       tit.Append(" ");
       tit.Append(o->GetTitle());
      }
      return e;
    }
  }

Some fixes to the train setup to show default values of the options.

PWGLF/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWGLF/FORWARD/analysis2/AliBasedNdetaTask.h
PWGLF/FORWARD/analysis2/AliFMDDensityCalculator.cxx
PWGLF/FORWARD/analysis2/AliFMDEventInspector.cxx
PWGLF/FORWARD/analysis2/AliFMDSharingFilter.cxx
PWGLF/FORWARD/analysis2/AliForwardMCMultiplicityTask.cxx
PWGLF/FORWARD/analysis2/AliForwardQATask.cxx
PWGLF/FORWARD/analysis2/trains/TrainSetup.C

index 92d8649..746dc8d 100644 (file)
@@ -199,14 +199,37 @@ AliBasedNdetaTask::MakeCentralityBin(const char* name,
   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();
@@ -229,11 +252,21 @@ AliBasedNdetaTask::SetNormalizationScheme(const char* what)
     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 
@@ -241,19 +274,16 @@ AliBasedNdetaTask::SetNormalizationScheme(UShort_t scheme)
 {
   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 
@@ -274,11 +304,17 @@ AliBasedNdetaTask::SetTriggerMask(UShort_t mask)
 { 
   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
 }
 
 //________________________________________________________________________
@@ -403,6 +439,7 @@ AliBasedNdetaTask::UserExec(Option_t *)
   }
 
   // Here, we get the update 
+#if 0
   if (!fSNNString) { 
     UShort_t sNN = forward->GetSNN();
     fSNNString = new TNamed("sNN", "");
@@ -421,7 +458,25 @@ AliBasedNdetaTask::UserExec(Option_t *)
 
     // 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);
 }
 
@@ -597,11 +652,11 @@ AliBasedNdetaTask::Terminate(Option_t *)
   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)
@@ -696,19 +751,43 @@ AliBasedNdetaTask::Terminate(Option_t *)
   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);
index 681e955..1772de5 100644 (file)
@@ -14,6 +14,7 @@
  * 
  */
 #include <AliAnalysisTaskSE.h>
+#include <TParameter.h>
 class TAxis;
 class TList;
 class TH2D;
@@ -179,6 +180,22 @@ public:
    */
   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 
    * 
    * @param scheme Normalisation scheme 
@@ -844,16 +861,26 @@ protected:
   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
index 4f92801..bec3bf9 100644 (file)
@@ -456,7 +456,11 @@ AliFMDDensityCalculator::CacheMaxWeights(const TAxis& axis)
   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(), 
index 6be9558..20d481d 100644 (file)
@@ -383,7 +383,8 @@ AliFMDEventInspector::StoreInformation(Int_t runNo)
   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));
@@ -397,8 +398,9 @@ AliFMDEventInspector::StoreInformation(Int_t runNo)
   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);
@@ -409,7 +411,6 @@ AliFMDEventInspector::StoreInformation(Int_t runNo)
   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);
@@ -419,8 +420,6 @@ AliFMDEventInspector::StoreInformation(Int_t runNo)
   fList->Add(v0a);
   fList->Add(nCp);
   fList->Add(dP);
-  
-
 }
 
 //____________________________________________________________________
index a7b1faf..0c2af0d 100644 (file)
@@ -224,7 +224,9 @@ AliFMDSharingFilter::Init(const TAxis& axis)
   // 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(),
index adf6a36..ad29e45 100644 (file)
@@ -237,8 +237,6 @@ AliForwardMCMultiplicityTask::InitializeSubs()
   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);
index 5b766c8..3971d77 100644 (file)
@@ -287,7 +287,7 @@ AliForwardQATask::InitializeSubs()
 
   fEventInspector.Init(*pv);
   fEnergyFitter.Init(*pe);
-  fSharingFilter.Init();
+  fSharingFilter.Init(*pe);
   fDensityCalculator.Init(*pe);
 
   this->Print();
index 2c09cbf..541afad 100644 (file)
@@ -933,6 +933,9 @@ protected:
     // Production mode - not used here 
     // plugin->SetProductionMode();
     
+    // Do not test copying 
+    plugin->SetCheckCopy(false);
+    
     // Set output to be per run 
     plugin->SetOutputToRunNo(true); 
 
@@ -2233,7 +2236,8 @@ public:
       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 
@@ -2445,6 +2449,7 @@ public:
     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++;
@@ -2561,6 +2566,50 @@ protected:
    * 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. 
+   */
   virtual void SetOptions(Runner& r)
   {
     Option* debug      = r.FindOption("debug");