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 92d86490e305d93906f9fe500f2b0b126c3fbe20..746dc8db349e5e6a6210b53e256cfde2bc8dc79f 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 681e955d3198f2a39fffa3dc2537c2fe5c5df9b6..1772de5738e1c7d8b18a6cadb3ad528d92deee7f 100644 (file)
@@ -14,6 +14,7 @@
  * 
  */
 #include <AliAnalysisTaskSE.h>
+#include <TParameter.h>
 class TAxis;
 class TList;
 class TH2D;
@@ -178,6 +179,22 @@ public:
    * @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 
    * 
@@ -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 4f9280107137833639a41bcdf3e1ccf1b8e36b8e..bec3bf93f2074779dd9cc3279c84d9b30a448cde 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 6be955867cf92c300e51342201b920a7ea03a14a..20d481dcc793f3b7a872a5be5e91381d4866ca87 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 a7b1faffe457729ad2266772c3c39197f72f1433..0c2af0d79cf0faa5c68bebe8e4461e12008c86eb 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 adf6a361ce47a27bc7bb14b74a8e2b79b7481601..ad29e4545f52a3863cef9c7573cb1bcaf1ff4147 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 5b766c84070da089010cc8a66854a9a47097164b..3971d776a0f63a8b4de3cb2105f63111cd66fd0e 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 2c09cbf5721d1a57170becac77be477869fbf119..541afadd12e109583925472dd51452eb20cb3f65 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++;
@@ -2557,6 +2562,50 @@ protected:
     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.