TMusrRunHeader.cpp

Go to the documentation of this file.

/***************************************************************************
 
  TMusrRunHeader.cpp
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <memory>
 
#include "TMusrRunHeader.h"
 
#include <TPaveText.h>
#include <TCanvas.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TString.h>
#include <TList.h>
#include <TMap.h>
#include <TKey.h>
 
ClassImp(TMusrRunPhysicalQuantity)
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunPhysicalQuantity::TMusrRunPhysicalQuantity() : TObject()
{
  fLabel  = "n/a";
  fDemand = MRH_UNDEFINED;
  fValue  = MRH_UNDEFINED;
  fError  = MRH_UNDEFINED;
  fUnit   = "n/a";
  fDescription = "n/a";
}
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunPhysicalQuantity::TMusrRunPhysicalQuantity(TString label, Double_t demand, Double_t value, Double_t error, TString unit, TString description) :
     TObject(), fLabel(label), fDemand(demand), fValue(value), fError(error), fUnit(unit)
{
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunPhysicalQuantity::TMusrRunPhysicalQuantity(TString label, Double_t demand, Double_t value, TString unit, TString description) :
     TObject(), fLabel(label), fDemand(demand), fValue(value), fUnit(unit)
{
  fError = MRH_UNDEFINED;
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunPhysicalQuantity::TMusrRunPhysicalQuantity(TString label, Double_t value, TString unit, TString description) :
     TObject(), fLabel(label), fValue(value), fUnit(unit)
{
  fDemand = MRH_UNDEFINED;
  fError  = MRH_UNDEFINED;
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunPhysicalQuantity::Set(TString label, Double_t demand, Double_t value, Double_t error, TString unit, TString description)
{
  fLabel = label;
  fDemand = demand;
  fValue = value;
  fError = error;
  fUnit = unit;
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunPhysicalQuantity::Set(TString label, Double_t demand, Double_t value, TString unit, TString description)
{
  fLabel = label;
  fDemand = demand;
  fValue = value;
  fError = MRH_UNDEFINED;
  fUnit = unit;
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunPhysicalQuantity::Set(TString label, Double_t value, TString unit, TString description)
{
  fLabel = label;
  fDemand = MRH_UNDEFINED;
  fValue = value;
  fError = MRH_UNDEFINED;
  fUnit = unit;
  if (description.IsWhitespace())
    fDescription = "n/a";
  else
    fDescription = description;
}
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
ClassImp(TMusrRunHeader)
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunHeader::TMusrRunHeader(bool quiet) : TObject(), fQuiet(quiet)
{
  Init();
}
 
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
TMusrRunHeader::TMusrRunHeader(const char *fileName, bool quiet) : TObject()
{
  fQuiet = quiet;
  Init(TString(fileName));
}
 
//--------------------------------------------------------------------------
// Init (private)
//--------------------------------------------------------------------------
void TMusrRunHeader::Init(TString fileName)
{
  TMusrRunPhysicalQuantity prop;
 
  fFileName = fileName;
  fVersion = TString("git-sha: dae9ef0ffba4");
  Set("RunInfo/Version", fVersion);
  Set("RunInfo/Generic Validator URL", "http://lmu.web.psi.ch/facilities/software/MusrRoot/validation/MusrRoot.xsd");
  Set("RunInfo/Specific Validator URL", "n/a");
  Set("RunInfo/Generator", "n/a");
  Set("RunInfo/Proposal Number", -1);
  Set("RunInfo/Main Proposer", "n/a");
  Set("RunInfo/File Name", "n/a");
  Set("RunInfo/Run Title", "n/a");
  Set("RunInfo/Run Number", -1);
  Set("RunInfo/Run Start Time", "1970-01-01 00:00:00");
  Set("RunInfo/Run Stop Time", "1970-01-01 00:00:00");
  prop.Set("Run Duration", 0.0, "sec");
  Set("RunInfo/Run Duration", prop);
  Set("RunInfo/Laboratory", "n/a");
  Set("RunInfo/Instrument", "n/a");
  prop.Set("Muon Beam Momentum", 0.0, "MeV/c");
  Set("RunInfo/Muon Beam Momentum", prop);
  Set("RunInfo/Muon Species", "n/a");
  Set("RunInfo/Muon Source", "n/a");
  Set("RunInfo/Setup", "n/a");
  Set("RunInfo/Comment", "n/a");
  Set("RunInfo/Sample Name", "n/a");
  prop.Set("Sample Temperature", 0.0, "K");
  Set("RunInfo/Sample Temperature", prop);
  prop.Set("Sample Magnetic Field", 1000.0, "T");
  Set("RunInfo/Sample Magnetic Field", prop);
  Set("RunInfo/No of Histos", 0);
  prop.Set("Time Resolution", 0.0, "ns");
  Set("RunInfo/Time Resolution", prop);
  std::vector<int> ivec;
  ivec.push_back(0);
  Set("RunInfo/RedGreen Offsets", ivec);
 
  Set("DetectorInfo/Detector001/Name", "n/a");
  Set("DetectorInfo/Detector001/Histo Number", 0);
  Set("DetectorInfo/Detector001/Histo Length", 0);
  Set("DetectorInfo/Detector001/Time Zero Bin", static_cast<Double_t>(0.0));
  Set("DetectorInfo/Detector001/First Good Bin", 0);
  Set("DetectorInfo/Detector001/Last Good Bin", 0);
 
  Set("SampleEnvironmentInfo/Cryo", "n/a");
 
  Set("MagneticFieldEnvironmentInfo/Magnet Name", "n/a");
 
  Set("BeamlineInfo/Name", "n/a");
}
 
//--------------------------------------------------------------------------
// Destructor
//--------------------------------------------------------------------------
TMusrRunHeader::~TMusrRunHeader()
{
  CleanUp();
}
 
//--------------------------------------------------------------------------
// CleanUp (private)
//--------------------------------------------------------------------------
void TMusrRunHeader::CleanUp()
{
  fStringObj.clear();
  fIntObj.clear();
  fDoubleObj.clear();
  fMusrRunPhysQuantityObj.clear();
  fStringVectorObj.clear();
  fIntVectorObj.clear();
  fDoubleVectorObj.clear();
 
  fPathNameOrder.clear();
}
 
//--------------------------------------------------------------------------
// FillFolder (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::FillFolder(TFolder *folder)
{
  TObjArray  *oarray;
  TObjString ostr, *p_ostr;
  TString path, name, str;
  Ssiz_t pos=0;
  bool found=false;
 
  if (folder == nullptr) {
    std::cerr << std::endl << ">> TMusrRunHeader::FillFolder(): **ERROR** folder == nullptr!!" << std::endl;
    return false;
  }
 
  folder->SetOwner(); // folder takes ownership of all added objects! This means that the folder object does the cleanup
 
  // update/generate tree structure in folder
  for (UInt_t i=0; i<fPathNameOrder.size(); i++) {
    path=fPathNameOrder[i];
 
    if (!UpdateFolder(folder, path))
      return false;
  }
 
  // update/generate tree content
  for (UInt_t i=0; i<fPathNameOrder.size(); i++) {
    path=fPathNameOrder[i];
    pos = path.Last('/');
    if (pos == -1) {
      std::cerr << std::endl << ">> TMusrRunHeader::FillFolder(): **ERROR** somethig is wrong with the path=" << path << " !!" << std::endl;
      return false;
    }
    path.Remove(pos); // remove the value from the path
 
    oarray = dynamic_cast<TObjArray*>(FindObject(folder, path));
    if (!oarray) {
      std::cerr << std::endl << ">> TMusrRunHeader::FillFolder(): **ERROR** couldn't create header structure!!" << std::endl;
      return false;
    }
 
    // check if <value> is already found in oarray
    ostr = GetHeaderString(i); // encode the string for the MusrRoot file
    name = ostr.GetString(); // convert to TString
    str = GetFirst(name, ':'); // get the first part of the encoded string, i.e. <nnn> - <name>
    found = false;
    for (Int_t j=0; j<oarray->GetEntriesFast(); j++) {
      p_ostr = dynamic_cast<TObjString*>(oarray->At(j));
      if (p_ostr->GetString().BeginsWith(str)) { // present hence replace
        oarray->AddAt(ostr.Clone(), j);
        found = true;
        break;
      }
    }
    if (!found) {
      oarray->AddLast(ostr.Clone());
    }
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// FillDirectory (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::FillDirectory(TDirectory *dir)
{
  if (dir == nullptr) {
    std::cerr << std::endl << ">> TMusrRunHeader::FillDirectory(): **ERROR** dir == nullptr!!" << std::endl;
    return false;
  }
 
  if (!UpdateDirTree(dir))
    return false;
 
  // update/generate tree content
  TString path, name, str;
  TObjString ostr, *p_ostr;
  Ssiz_t pos=0;
  TDirectory *currDir=nullptr;
  TObjArray *oarray=nullptr;
  Bool_t found;
  for (UInt_t i=0; i<fPathNameOrder.size(); i++) {
    path=fPathNameOrder[i];
    pos = path.Last('/');
    if (pos == -1) {
      std::cerr << std::endl << ">> TMusrRunHeader::FillDirectory(): **ERROR** somethig is wrong with the path=" << path << " !!" << std::endl;
      return false;
    }
    path.Remove(pos); // remove the value from the path
    dir->cd(path);
    currDir = dir->CurrentDirectory();
    if (currDir->GetList()->Last() == nullptr) { // no oarray present, hence create it
      oarray = new TObjArray();
    } else {
      oarray = dynamic_cast<TObjArray*>(currDir->GetList()->First());
    }
 
    // check if <value> is already found in oarray
    ostr = GetHeaderString(i); // encode the string for the MusrRoot file
    name = ostr.GetString(); // convert to TString
    str = GetFirst(name, ':'); // get the first part of the encoded string, i.e. <nnn> - <name>
    found = false;
    for (Int_t j=0; j<oarray->GetEntriesFast(); j++) {
      p_ostr = dynamic_cast<TObjString*>(oarray->At(j));
      if (p_ostr->GetString().BeginsWith(str)) { // present hence replace
        oarray->AddAt(ostr.Clone(), j);
        found = true;
        break;
      }
    }
    if (!found) {
      oarray->AddLast(ostr.Clone());
    }
    oarray->Write();
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// GetTypeOfPath (public)
//--------------------------------------------------------------------------
TString TMusrRunHeader::GetTypeOfPath(TString pathName)
{
  TString type("undef");
 
  // find pathName
  for (Int_t i=0; i<fStringObj.size(); i++) {
    if (fStringObj[i].GetPathName() == pathName) {
      type = fStringObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fIntObj.size(); i++) {
    if (fIntObj[i].GetPathName() == pathName) {
      type = fIntObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fDoubleObj.size(); i++) {
    if (fDoubleObj[i].GetPathName() == pathName) {
      type = fDoubleObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fMusrRunPhysQuantityObj.size(); i++) {
    if (fMusrRunPhysQuantityObj[i].GetPathName() == pathName) {
      type = fMusrRunPhysQuantityObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fStringVectorObj.size(); i++) {
    if (fStringVectorObj[i].GetPathName() == pathName) {
      type = fStringVectorObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fIntVectorObj.size(); i++) {
    if (fIntVectorObj[i].GetPathName() == pathName) {
      type = fIntVectorObj[i].GetType();
      return type;
    }
  }
  for (Int_t i=0; i<fDoubleVectorObj.size(); i++) {
    if (fDoubleVectorObj[i].GetPathName() == pathName) {
      type = fDoubleVectorObj[i].GetType();
      return type;
    }
  }
 
 
  return type;
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, TString &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fStringObj.size(); i++) {
    if (fStringObj[i].GetPathName() == pathName) {
      value = fStringObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, Int_t &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fIntObj.size(); i++) {
    if (fIntObj[i].GetPathName() == pathName) {
      value = fIntObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, Double_t &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fDoubleObj.size(); i++) {
    if (fDoubleObj[i].GetPathName() == pathName) {
      value = fDoubleObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, TMusrRunPhysicalQuantity &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fMusrRunPhysQuantityObj.size(); i++) {
    if (fMusrRunPhysQuantityObj[i].GetPathName() == pathName) {
      value = fMusrRunPhysQuantityObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, TStringVector &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fStringVectorObj.size(); i++) {
    if (fStringVectorObj[i].GetPathName() == pathName) {
      value = fStringVectorObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, TIntVector &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fIntVectorObj.size(); i++) {
    if (fIntVectorObj[i].GetPathName() == pathName) {
      value = fIntVectorObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Get (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Get(TString pathName, TDoubleVector &value, Bool_t &ok)
{
  ok = false;
 
  for (UInt_t i=0; i<fDoubleVectorObj.size(); i++) {
    if (fDoubleVectorObj[i].GetPathName() == pathName) {
      value = fDoubleVectorObj[i].GetValue();
      ok = true;
    }
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, TString value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fStringObj.size(); i++) {
    if (!fStringObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fStringObj[i].SetType("TString");
      fStringObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fStringObj.size()) {
    // feed object
    TMusrRunObject<TString> obj(pathName, "TString", value);
    fStringObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, Int_t value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fIntObj.size(); i++) {
    if (!fIntObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fIntObj[i].SetType("Int_t");
      fIntObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fIntObj.size()) {
    // feed object
    TMusrRunObject<Int_t> obj(pathName, "Int_t", value);
    fIntObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, Double_t value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fDoubleObj.size(); i++) {
    if (!fDoubleObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fDoubleObj[i].SetType("Double_t");
      fDoubleObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fDoubleObj.size()) {
    // feed object
    TMusrRunObject<Double_t> obj(pathName, "Double_t", value);
    fDoubleObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, TMusrRunPhysicalQuantity value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fMusrRunPhysQuantityObj.size(); i++) {
    if (!fMusrRunPhysQuantityObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fMusrRunPhysQuantityObj[i].SetType("TMusrRunHeader");
      fMusrRunPhysQuantityObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fMusrRunPhysQuantityObj.size()) {
    // feed object
    TMusrRunObject<TMusrRunPhysicalQuantity> obj(pathName, "TMusrRunPhysicalQuantity", value);
    fMusrRunPhysQuantityObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, TStringVector value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fStringVectorObj.size(); i++) {
    if (!fStringVectorObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fStringVectorObj[i].SetType("TStringVector");
      fStringVectorObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fStringVectorObj.size()) {
    // feed object
    TMusrRunObject<TStringVector> obj(pathName, "TStringVector", value);
    fStringVectorObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, TIntVector value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fIntVectorObj.size(); i++) {
    if (!fIntVectorObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fIntVectorObj[i].SetType("TIntVector");
      fIntVectorObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fIntVectorObj.size()) {
    // feed object
    TMusrRunObject<TIntVector> obj(pathName, "TIntVector", value);
    fIntVectorObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
//--------------------------------------------------------------------------
// Set (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::Set(TString pathName, TDoubleVector value)
{
  // check if pathName is already set, if not add it as a new entry, otherwise replace it
  UInt_t i=0;
  for (i=0; i<fDoubleVectorObj.size(); i++) {
    if (!fDoubleVectorObj[i].GetPathName().CompareTo(pathName, TString::kIgnoreCase)) {
      if (!fQuiet)
        std::cerr << std::endl << ">> **WARNING** " << pathName.Data() << " already exists, will replace it." << std::endl;
      fDoubleVectorObj[i].SetType("TDoubleVector");
      fDoubleVectorObj[i].SetValue(value);
      break;
    }
  }
 
  // if not found in the previous loop, it is a new object
  if (i == fDoubleVectorObj.size()) {
    // feed object
    TMusrRunObject<TDoubleVector> obj(pathName, "TDoubleVector", value);
    fDoubleVectorObj.push_back(obj);
 
    // feed path-name to keep track of the order
    fPathNameOrder.push_back(pathName);
  }
}
 
 
//--------------------------------------------------------------------------
// ExtractAll (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::ExtractAll(TFolder *folder)
{
  TIter next(folder->GetListOfFolders());
  TObjArray* entry;
 
  // clean up all internal structures - just in case this is called multiple times
  CleanUp();
 
  while ((entry = dynamic_cast<TObjArray*>(next()))) {
    ExtractHeaderInformation(entry, entry->GetName());
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// ExtractAll (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::ExtractAll(TDirectory *dir)
{
  TIter next(dir->GetListOfKeys());
  TKey *key;
  TObjString *entry;
 
  // clean up all internal structures - just in case this is called multiple times
  if (!strcmp(dir->GetName(), "RunHeader")) {
    CleanUp();
  }
 
  while ((key = (TKey*)next())) {
    if (strcmp(key->GetClassName(), "TDirectoryFile") == 0) {
      TDirectory *subdir = (TDirectory*)key->ReadObj();
      ExtractAll(subdir);
    } else if (strcmp(key->GetClassName(), "TObjString") == 0) {
      entry = (TObjString*)key->ReadObj();
      TString str = dir->GetPath();
      Ssiz_t start_idx = str.Index("RunHeader/");
      start_idx += 10; // got to end of 'RunHeader/'
      ExtractHeaderInformationData(entry, str(start_idx, str.Length()-start_idx));
    }
  }
 
  return true;
}
 
 
//--------------------------------------------------------------------------
// ExtractHeaderInformationData (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)
{
  TString label(""), pathName(""), str(""), strValue(""), type("");
  TObjString *ostr = nullptr;
  TObjArray *tokens = nullptr;
  Ssiz_t idx1;
  Int_t  intValue;
  Double_t dval;
 
  ostr = dynamic_cast<TObjString*>(headerData);
  str = ostr->GetString();
 
  // get the run header label
  label = GetLabel(str);
  if (label == "n/a") // not a TMusrRunHeader object, hence ignore it
    return true;
 
  // get the run header 'value'
  strValue = GetStrValue(str);
 
  // construct path name
  pathName = requestedPath + TString("/") + label;
 
  // get type from map
  type = GetType(str);
  if (type == "n/a") // not a TMusrRunHeader object, hence ignore it
    return true;
 
  if (type == "TString") {
    Set(pathName, strValue);
  } else if (type == "Int_t") {
    intValue = strValue.Atoi();
    Set(pathName, intValue);
  } else if (type == "Double_t") {
    dval = strValue.Atof();
    Set(pathName, dval);
  } else if (type == "TMusrRunPhysicalQuantity") {
    TMusrRunPhysicalQuantity prop;
    prop.SetLabel(label);
 
    // 1st get the description if present
    tokens = strValue.Tokenize(";");
    if (tokens == nullptr) {
      std::cerr << std::endl << ">> **ERROR** Couldn't tokenize entry in Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)" << std::endl;
      return false;
    }
 
    switch (tokens->GetEntries()) {
      case 2:
        ostr = dynamic_cast<TObjString*>(tokens->At(1));
        str = ostr->GetString();
        if (!str.Contains("SP:")) { // make sure that it is not a demand value token
          prop.SetDescription(str);
        }
        break;
      case 3:
        ostr = dynamic_cast<TObjString*>(tokens->At(2));
        str = ostr->GetString();
        break;
      default:
        break;
    }
 
    if (tokens) {
      delete tokens;
      tokens = nullptr;
    }
 
    // 2nd collect all the other properties, this is easier when first a potential description is removed
    idx1 = strValue.Last(';');
    if (idx1 > 0) {
      TString last("");
      for (Int_t i=idx1+2; i<strValue.Length(); i++)
        last += strValue[i];
      // check if last is <description> or SP: <demand>
      if (!last.Contains("SP:")) {
        str = "";
        for (Int_t i=0; i<idx1; i++)
          str += strValue[i];
        strValue = str;
      }
    }
 
    tokens = strValue.Tokenize(" +;");
    if (tokens == nullptr) {
      std::cerr << std::endl << ">> **ERROR** Couldn't tokenize entry in Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)" << std::endl;
      return false;
    }
 
    switch (tokens->GetEntries()) {
      case 2: // <val> <unit>
        ostr = dynamic_cast<TObjString*>(tokens->At(0));
        str = ostr->GetString();
        prop.SetValue(str.Atof());
        ostr = dynamic_cast<TObjString*>(tokens->At(1));
        str = ostr->GetString();
        prop.SetUnit(str);
        break;
      case 4: // <val> +- <err> <unit>, or <val> <unit>; SP: <demand>
        ostr = dynamic_cast<TObjString*>(tokens->At(0));
        str = ostr->GetString();
        prop.SetValue(str.Atof());
        ostr = dynamic_cast<TObjString*>(tokens->At(1));
        str = ostr->GetString();
        if (str == "-") { // <val> +- <err> <unit>
          ostr = dynamic_cast<TObjString*>(tokens->At(2));
          str = ostr->GetString();
          prop.SetError(str.Atof());
          ostr = dynamic_cast<TObjString*>(tokens->At(3));
          str = ostr->GetString();
          prop.SetUnit(str);
        } else { // <val> <unit>; SP: <demand>
          prop.SetUnit(str);
          ostr = dynamic_cast<TObjString*>(tokens->At(3));
          str = ostr->GetString();
          prop.SetDemand(str.Atof());
        }
        break;
      case 6: // <val> +- <err> <unit>; SP: <demand>
        ostr = dynamic_cast<TObjString*>(tokens->At(0));
        str = ostr->GetString();
        prop.SetValue(str.Atof());
        ostr = dynamic_cast<TObjString*>(tokens->At(2));
        str = ostr->GetString();
        prop.SetError(str.Atof());
        ostr = dynamic_cast<TObjString*>(tokens->At(3));
        str = ostr->GetString();
        prop.SetUnit(str);
        ostr = dynamic_cast<TObjString*>(tokens->At(5));
        str = ostr->GetString();
        prop.SetDemand(str.Atof());
        break;
      default:
        break;
    }
 
    if (tokens) {
      delete tokens;
      tokens = nullptr;
    }
 
    Set(pathName, prop);
  } else if (type == "TStringVector") {
    TStringVector svec;
    tokens = strValue.Tokenize(";");
    if (tokens == nullptr) {
      std::cerr << std::endl << ">> **ERROR** Couldn't tokenize entry in Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)" << std::endl;
      return false;
    }
    for (Int_t i=0; i<tokens->GetEntries(); i++) {
      ostr = dynamic_cast<TObjString*>(tokens->At(i));
      str = ostr->GetString();
      str.Remove(TString::kBoth, ' ');
      svec.push_back(str);
    }
    if (tokens) {
      delete tokens;
      tokens = nullptr;
    }
    Set(pathName, svec);
  } else if (type == "TIntVector") {
    TIntVector ivec;
    tokens = strValue.Tokenize(";");
    if (tokens == nullptr) {
      std::cerr << std::endl << ">> **ERROR** Couldn't tokenize entry in Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)" << std::endl;
      return false;
    }
    for (Int_t i=0; i<tokens->GetEntries(); i++) {
      ostr = dynamic_cast<TObjString*>(tokens->At(i));
      ivec.push_back(ostr->GetString().Atoi());
    }
    if (tokens) {
      delete tokens;
      tokens = nullptr;
    }
    Set(pathName, ivec);
  } else if (type == "TDoubleVector") {
    TDoubleVector dvec;
    tokens = strValue.Tokenize(";");
    if (tokens == nullptr) {
      std::cerr << std::endl << ">> **ERROR** Couldn't tokenize entry in Bool_t TMusrRunHeader::ExtractHeaderInformationData(TObjString *headerData, TString requestedPath)" << std::endl;
      return false;
    }
    for (Int_t i=0; i<tokens->GetEntries(); i++) {
      ostr = dynamic_cast<TObjString*>(tokens->At(i));
      dvec.push_back(ostr->GetString().Atof());
    }
    if (tokens) {
      delete tokens;
      tokens = nullptr;
    }
    Set(pathName, dvec);
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// ExtractHeaderInformation (public)
//--------------------------------------------------------------------------
Bool_t TMusrRunHeader::ExtractHeaderInformation(TObjArray *headerInfo, TString requestedPath)
{
  TString label(""), path(""), pathName(""), str(""), strValue(""), type("");
  TObjString *ostr = nullptr;
  TObjArray *tokens = nullptr;
  Ssiz_t idx1;
  Int_t  intValue;
  Double_t dval;
 
  // go through all entries of this header information from the MUSR-ROOT file
  for (Int_t i=0; i<headerInfo->GetEntries(); i++) {
    // check if entry is a TObjArray, i.e. a sub tree
    str = TString(headerInfo->At(i)->ClassName());
    if (str == "TObjArray") { // sub tree
      path = requestedPath + "/" + TString(headerInfo->At(i)->GetName());
      ExtractHeaderInformation(dynamic_cast<TObjArray*>(headerInfo->At(i)), path);
    } else { // handle all the rest, i.e. already data
      ostr = dynamic_cast<TObjString*>(headerInfo->At(i));
      if (!ExtractHeaderInformationData(ostr, requestedPath))
        return false;
    }
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// DumpHeader (public)
//--------------------------------------------------------------------------
void TMusrRunHeader::DumpHeader()
{
  std::cout << std::endl << "***************************************";
  std::cout << std::endl << "header info of file : " << fFileName;
  std::cout << std::endl << "***************************************";
 
  TString str(""), tstr(""), fmt(""), path(""), name(""), currentPath("");
  TMusrRunPhysicalQuantity prop;
 
  for (UInt_t i=0; i<fPathNameOrder.size(); i++) {
    // print path if new
    SplitPathName(fPathNameOrder[i], path, name);
    if (path != currentPath) {
      currentPath = path;
      std::cout << std::endl << currentPath;
    }
 
    // go through all objects and try to find it
    // 1st check TString
    for (UInt_t j=0; j<fStringObj.size(); j++) {
      if (fStringObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fStringObj[j].GetPathName(), path, name);
        str.Form("  %03d - %s: %s -@%d", i, name.Data(), fStringObj[j].GetValue().Data(), MRH_TSTRING);
        std::cout << std::endl << str;
      }
    }
    // 2nd check Int_t
    for (UInt_t j=0; j<fIntObj.size(); j++) {
      if (fIntObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fIntObj[j].GetPathName(), path, name);
        str.Form("  %03d - %s: %d -@%d", i, name.Data(), fIntObj[j].GetValue(), MRH_INT);
        std::cout << std::endl << str;
      }
    }
    // 3rd check Double_t
    for (UInt_t j=0; j<fDoubleObj.size(); j++) {
      if (fDoubleObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fDoubleObj[j].GetPathName(), path, name);
        fmt.Form("  %%03d - %%s: %%.%dlf -@%%d", MRH_DOUBLE_PREC);
        str.Form(fmt, i, name.Data(), fDoubleObj[j].GetValue(), MRH_DOUBLE);
        std::cout << std::endl << str;
      }
    }
    // 4th check TMusrRunPhysicalQuantity
    for (UInt_t j=0; j<fMusrRunPhysQuantityObj.size(); j++) {
      if (fMusrRunPhysQuantityObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        prop = fMusrRunPhysQuantityObj[j].GetValue();
        Int_t digit, digit_d;
        if ((prop.GetDemand() != MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() != MRH_UNDEFINED) &&
            (prop.GetUnit() != "n/a")) { // <value> +- <error> <unit>; SP: <demand> [; <description>]
          digit = GetDecimalPlace(prop.GetError());
          digit_d = GetLeastSignificantDigit(prop.GetDemand());
          if (prop.GetDescription() != "n/a") {
            fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; SP: %%.%dlf; %%s", digit, digit, digit_d);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDemand(), prop.GetDescription().Data());
          } else {
            fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; SP: %%.%dlf", digit, digit, digit_d);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDemand());
          }
        } else if ((prop.GetDemand() == MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() != MRH_UNDEFINED) &&
                   (prop.GetUnit() != "n/a")) { // <value> +- <error> <unit> [; <description>]
          digit = GetDecimalPlace(prop.GetError());
          if (prop.GetDescription() != "n/a") {
            fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; %%s", digit, digit);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDescription().Data());
          } else {
            fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s", digit, digit);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data());
          }
        } else if ((prop.GetDemand() == MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() == MRH_UNDEFINED) &&
                   (prop.GetUnit() != "n/a")) { // <value> <unit> [; <description>]
          digit = GetLeastSignificantDigit(prop.GetValue());
          if (prop.GetDescription() != "n/a") {
            fmt.Form("%%s: %%.%dlf %%s; %%s", digit);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDescription().Data());
          } else {
            fmt.Form("%%s: %%.%dlf %%s", digit);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data());
          }
        } else if ((prop.GetDemand() != MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() == MRH_UNDEFINED) &&
                   (prop.GetUnit() != "n/a")) { // <value> <unit>; SP: <demand> [; <description>]
          digit = GetLeastSignificantDigit(prop.GetValue());
          digit_d = GetLeastSignificantDigit(prop.GetDemand());
          if (prop.GetDescription() != "n/a") {
            fmt.Form("%%s: %%.%dlf %%s; SP: %%.%dlf; %%s", digit, digit_d);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDemand(), prop.GetDescription().Data());
          } else {
            fmt.Form("%%s: %%.%dlf %%s; SP: %%.%dlf", digit, digit_d);
            tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDemand());
          }
        } else if (prop.GetValue() == MRH_UNDEFINED) { // <value> = n/a
          fmt.Form("%%s: %%s %%s");
          if ((prop.GetUnit() != "n/a"))
            tstr.Form(fmt, prop.GetLabel().Data(), "n/a", prop.GetUnit().Data());
          else
            tstr.Form(fmt, prop.GetLabel().Data(), "n/a", "n/a");
        }
        str.Form("  %03d - %s -@%d", i, tstr.Data(), MRH_TMUSR_RUN_PHYSICAL_QUANTITY);
        std::cout << std::endl << str;
      }
    }
    // 5th check TStringVector
    for (UInt_t j=0; j<fStringVectorObj.size(); j++) {
      if (fStringVectorObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fStringVectorObj[j].GetPathName(), path, name);
        str.Form("  %03d - %s: ", i, name.Data());
        TStringVector vstr = fStringVectorObj[j].GetValue();
        for (UInt_t k=0; k<vstr.size()-1; k++)
          str += vstr[k] + "; ";
        str += vstr[vstr.size()-1];
        str += " -@";
        str += MRH_TSTRING_VECTOR;
        std::cout << std::endl << str;
      }
    }
    // 6th check TIntVector
    for (UInt_t j=0; j<fIntVectorObj.size(); j++) {
      if (fIntVectorObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fIntVectorObj[j].GetPathName(), path, name);
        str.Form("  %03d - %s: ", i, name.Data());
        TIntVector vint = fIntVectorObj[j].GetValue();
        for (UInt_t k=0; k<vint.size()-1; k++) {
          str += vint[k];
          str += "; ";
        }
        str += vint[vint.size()-1];
        str += " -@";
        str += MRH_INT_VECTOR;
        std::cout << std::endl << str;
      }
    }
    // 7th check TDoubleVector
    for (UInt_t j=0; j<fDoubleVectorObj.size(); j++) {
      if (fDoubleVectorObj[j].GetPathName() == fPathNameOrder[i]) { // found correct object
        SplitPathName(fDoubleVectorObj[j].GetPathName(), path, name);
        str.Form("  %03d - %s: ", i, name.Data());
        TDoubleVector dvec = fDoubleVectorObj[j].GetValue();
        TString subStr("");
        fmt.Form("%%.%dlf", MRH_DOUBLE_PREC);
        for (UInt_t k=0; k<dvec.size()-1; k++) {
          subStr.Form(fmt, dvec[k]);
          str += subStr;
          str += "; ";
        }
        subStr.Form(fmt, dvec[dvec.size()-1]);
        str += subStr;
        str += " -@";
        str += MRH_DOUBLE_VECTOR;
        std::cout << std::endl << str;
      }
    }
  }
 
  std::cout << std::endl;
}
 
//--------------------------------------------------------------------------
// GetDecimalPlace (private)
//--------------------------------------------------------------------------
UInt_t TMusrRunHeader::GetDecimalPlace(Double_t val)
{
  UInt_t digit = 0;
 
  if (val < 1.0) {
    UInt_t count=1;
    do {
      val *= 10.0;
      if (val > 1.0)
        digit = count;
      count++;
    } while ((digit == 0) && (count < 20));
  }
 
  return digit;
}
 
//--------------------------------------------------------------------------
// GetLeastSignificantDigit (private)
//--------------------------------------------------------------------------
UInt_t TMusrRunHeader::GetLeastSignificantDigit(Double_t val) const
{
  char cstr[1024];
  snprintf(cstr, sizeof(cstr), "%.10lf", val);
 
  int i=0, j=0;
  for (i=strlen(cstr)-1; i>=0; i--) {
    if (cstr[i] != '0')
      break;
  }
 
  for (j=strlen(cstr)-1; j>=0; j--) {
    if (cstr[j] == '.')
      break;
  }
  if (j==0) // no decimal point present, e.g. 321
    j=i;
 
  return i-j;
}
 
//--------------------------------------------------------------------------
// SplitPathName (private)
//--------------------------------------------------------------------------
void TMusrRunHeader::SplitPathName(TString pathName, TString &path, TString &name)
{
  path = TString("");
  name = TString("");
  Ssiz_t idx = pathName.Last('/');
 
  for (Int_t i=0; i<idx; i++)
    path += pathName[i];
 
  for (Int_t i=idx+1; i<pathName.Length(); i++)
    name += pathName[i];
}
 
//--------------------------------------------------------------------------
// GetLabel (private)
//--------------------------------------------------------------------------
TString TMusrRunHeader::GetLabel(TString str)
{
  // get run header label
  // the string 'str' should have the structure
  // <number> - <runHeader label>: <runHeader string value> -@<encoded data type>
 
  TString label = TString("n/a");
  Ssiz_t idx1 = str.First('-');
  Ssiz_t idx2 = str.First(':');
  if ((idx1 == -1) || (idx2 == -1)) {
    if (!fQuiet) {
      std::cerr << std::endl << ">> TMusrRunHeader::GetLabel(): **WARNING** str='" << str << "', seems not correctly encoded.";
      std::cerr << std::endl << ">>   Will omit it." << std::endl;
    }
    return label;
  }
 
  label = TString("");
  for (Int_t j=idx1+2; j<idx2; j++)
    label += str[j];
 
  return label;
}
 
//--------------------------------------------------------------------------
// GetStrValue (private)
//--------------------------------------------------------------------------
TString TMusrRunHeader::GetStrValue(TString str)
{
  // get run header string value
  // the string 'str' should have the structure
  // <number> - <runHeader label>: <runHeader string value> -@<encoded data type>
 
  TString strValue = TString("n/a");
  Ssiz_t idx1 = str.First(':');
  Ssiz_t idx2 = str.Last('-');
  if ((idx1 == -1) || (idx2 == -1)) {
    if (!fQuiet) {
      std::cerr << std::endl << ">> TMusrRunHeader::GetStrValue(): **WARNING** str='" << str << "', seems not correctly encoded.";
      std::cerr << std::endl << ">>   Will omit it." << std::endl;
    }
    return strValue;
  }
 
  strValue = TString("");
  for (Int_t j=idx1+2; j<idx2-1; j++)
    strValue += str[j];
 
  return strValue;
}
 
//--------------------------------------------------------------------------
// GetType (private)
//--------------------------------------------------------------------------
TString TMusrRunHeader::GetType(TString str)
{
  TString result = "n/a";
 
  // the string 'str' should have the structure
  // <number> - <runHeader label>: <runHeader string value> -@<encoded data type>
  Ssiz_t pos = str.Last('@');
 
  if (pos == -1) { // i.e. NOT found
    if (!fQuiet) {
      std::cerr << std::endl << ">> TMusrRunHeader::GetType(): **WARNING** str=" << str << " seems to be an invalid MusrROOT run header string.";
      std::cerr << std::endl << ">>   Will omit it." << std::endl;
    }
    return result;
  }
 
  // filter out the encoded type declaration, i.e. -@<num>, where <num> is the encoded type
  TString typeStr(str);
  typeStr.Remove(0, pos+1);
  Int_t typeVal;
  if (!typeStr.IsDigit()) {
    std::cerr << std::endl << ">> TMusrRunHeader::GetType(): **ERROR** typeStr=" << typeStr << " is not supported." << std::endl;
    return result;
  }
 
  typeVal = typeStr.Atoi();
 
  switch (typeVal) {
  case MRH_TSTRING:
    result = "TString";
    break;
  case MRH_INT:
    result = "Int_t";
    break;
  case MRH_DOUBLE:
    result = "Double_t";
    break;
  case MRH_TMUSR_RUN_PHYSICAL_QUANTITY:
    result = "TMusrRunPhysicalQuantity";
    break;
  case MRH_TSTRING_VECTOR:
    result = "TStringVector";
    break;
  case MRH_INT_VECTOR:
    result = "TIntVector";
    break;
  case MRH_DOUBLE_VECTOR:
    result = "TDoubleVector";
    break;
  default:
    std::cerr << std::endl << ">> TMusrRunHeader::GetType(): **ERROR** found unsupport type encoded with: " << typeVal << "." << std::endl;
    break;
  }
 
  return result;
}
 
//--------------------------------------------------------------------------
// UpdateFolder (private)
//--------------------------------------------------------------------------
bool TMusrRunHeader::UpdateFolder(TObject *treeObj, TString path)
{
  if (path.First('/') == -1) // only value element left, hence nothing to be done
    return true;
 
  TString str = GetFirst(path, '/');
 
  TObject *obj = treeObj->FindObject(str);
 
  // remove the first path element
  if (!RemoveFirst(path, '/')) {
    std::cerr << std::endl << ">> TMusrRunHeader::UpdateFolder(): **ERROR** couldn't tokenize path!!" << std::endl;
    return false;
  }
 
  if (!obj) { // required object not present, create it
    TObjArray *oarray = new TObjArray();
    if (oarray == nullptr) {
      std::cerr << std::endl << ">> TMusrRunHeader::UpdateFolder(): **ERROR** couldn't create header structure!!" << std::endl;
      return false;
    }
    // set the name of the new TObjArray
    oarray->SetName(str);
 
    if (!strcmp(treeObj->ClassName(), "TFolder"))
      (dynamic_cast<TFolder*>(treeObj))->Add(oarray);
    else // it is a TObjArray
      (dynamic_cast<TObjArray*>(treeObj))->AddLast(oarray);
 
    return UpdateFolder(oarray, path);
  } else { // object present, hence check rest of the path
    return UpdateFolder(obj, path);
  }
}
 
//--------------------------------------------------------------------------
// UpdateDirTree (private)
//--------------------------------------------------------------------------
bool TMusrRunHeader::UpdateDirTree(TDirectory *topdir)
{
  if (strcmp(topdir->GetName(), "RunHeader")) {
    std::cerr << std::endl << ">> TMusrRunHeader::UpdateDirTree(): **ERROR** top dir has to be named RunHeader, found '" << topdir->GetName() << "' !" << std::endl;
    return false;
  }
 
  TDirectory *dir;
  TObjArray *tok = nullptr;
  TObjString *ostr = nullptr;
  TString tstr{""};
  TObject *obj;
  for (TString str : fPathNameOrder) { // loop through all path-names
    dir = topdir;
    if (tok != nullptr)
      delete tok;
    tok = str.Tokenize("/");
    for (UInt_t i=0; i<tok->GetEntries(); i++) {
      ostr = dynamic_cast<TObjString*>(tok->At(i));
      tstr = ostr->GetString();
      if (i != tok->GetEntries()-1) { // TDirectory
        if ((obj = topdir->FindObjectAny(tstr.Data())) == nullptr) { // TDirectory new
          TDirectory *ndir = dir->mkdir(tstr.Data());
          dir = ndir;
        } else { // TDirectory exists
          dir = dynamic_cast<TDirectory*>(obj);
        }
      }
    }
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// FindObject (private)
//--------------------------------------------------------------------------
TObject* TMusrRunHeader::FindObject(TObject *treeObj, TString path)
{
  Ssiz_t pos;
  TObject *obj=nullptr;
 
  // make sure that treeObj is either TFolder or TObjArray
  if (strcmp(treeObj->ClassName(), "TFolder") && strcmp(treeObj->ClassName(), "TObjArray"))
    return obj;
 
  pos = path.First('/');
  if (pos == -1) { // i.e. no sub-paths anymore
    obj = treeObj->FindObject(path);
    return obj;
  } else { // sub-paths present
    TString objName = GetFirst(path, '/'); // get first token of the path <objName0>/<objName1>/.../<objNameN>
    obj = treeObj->FindObject(objName);
    if (obj) { // object found, check for subPath object
      RemoveFirst(path, '/'); // remove first tokens of the path
      return FindObject(obj, path);
    } else { // object not found
      return obj;
    }
  }
}
 
//--------------------------------------------------------------------------
// GetHeaderString (private)
//--------------------------------------------------------------------------
TObjString TMusrRunHeader::GetHeaderString(UInt_t idx)
{
  TObjString tostr("n/a");
 
  TString str(""), path(""), name(""), fmt(""), tstr("");
  TMusrRunPhysicalQuantity prop;
 
  // go through all objects and try to find it
  // 1st check TString
  for (UInt_t j=0; j<fStringObj.size(); j++) {
    if (fStringObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fStringObj[j].GetPathName(), path, name);
      str.Form("%03d - %s: %s -@%d", idx, name.Data(), fStringObj[j].GetValue().Data(), MRH_TSTRING);
      tostr.SetString(str);
    }
  }
  // 2nd check Int_t
  for (UInt_t j=0; j<fIntObj.size(); j++) {
    if (fIntObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fIntObj[j].GetPathName(), path, name);
      str.Form("%03d - %s: %d -@%d", idx, name.Data(), fIntObj[j].GetValue(), MRH_INT);
      tostr.SetString(str);
    }
  }
  // 3rd check Double_t
  for (UInt_t j=0; j<fDoubleObj.size(); j++) {
    if (fDoubleObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fDoubleObj[j].GetPathName(), path, name);
      fmt.Form("%%03d - %%s: %%.%dlf -@%%d", MRH_DOUBLE_PREC);
      str.Form(fmt, idx, name.Data(), fDoubleObj[j].GetValue(), MRH_DOUBLE);
      tostr.SetString(str);
    }
  }
  // 4th check TMusrRunPhysicalQuantity
  for (UInt_t j=0; j<fMusrRunPhysQuantityObj.size(); j++) {
    if (fMusrRunPhysQuantityObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      prop = fMusrRunPhysQuantityObj[j].GetValue();
      Int_t digit, digit_d;
      if ((prop.GetDemand() != MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() != MRH_UNDEFINED) &&
          (prop.GetUnit() != "n/a")) { // <value> +- <error> <unit>; SP: <demand> [; <description>]
        digit = GetDecimalPlace(prop.GetError());
        digit_d = GetLeastSignificantDigit(prop.GetDemand());
        if (prop.GetDescription() != "n/a") {
          fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; SP: %%.%dlf; %%s", digit, digit, digit_d);
 
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDemand(), prop.GetDescription().Data());
        } else {
          fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; SP: %%.%dlf", digit, digit, digit_d);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDemand());
        }
      } else if ((prop.GetDemand() == MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() != MRH_UNDEFINED) &&
                 (prop.GetUnit() != "n/a")) { // <value> +- <error> <unit> [; <description>]
        digit = GetDecimalPlace(prop.GetError());
        if (prop.GetDescription() != "n/a") {
          fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s; %%s", digit, digit);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data(), prop.GetDescription().Data());
        } else {
          fmt.Form("%%s: %%.%dlf +- %%.%dlf %%s", digit, digit);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetError(), prop.GetUnit().Data());
        }
      } else if ((prop.GetDemand() == MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() == MRH_UNDEFINED) &&
                 (prop.GetUnit() != "n/a")) { // <value> <unit> [; <description>]
        digit = GetLeastSignificantDigit(prop.GetValue());
        if (prop.GetDescription() != "n/a") {
          fmt.Form("%%s: %%.%dlf %%s; %%s", digit);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDescription().Data());
        } else {
          fmt.Form("%%s: %%.%dlf %%s", digit);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data());
        }
      } else if ((prop.GetDemand() != MRH_UNDEFINED) && (prop.GetValue() != MRH_UNDEFINED) && (prop.GetError() == MRH_UNDEFINED) &&
                 (prop.GetUnit() != "n/a")) { // <value> <unit>; SP: <demand> [; <description>]
        digit = GetLeastSignificantDigit(prop.GetValue());
        digit_d = GetLeastSignificantDigit(prop.GetDemand());
        if (prop.GetDescription() != "n/a") {
          fmt.Form("%%s: %%.%dlf %%s; SP: %%.%dlf; %%s", digit, digit_d);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDemand(), prop.GetDescription().Data());
        } else {
          fmt.Form("%%s: %%.%dlf %%s; SP: %%.%dlf", digit, digit_d);
          tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data(), prop.GetDemand());
        }
      } else if (prop.GetValue() == MRH_UNDEFINED) {
        fmt.Form("%%s: %%.1e %%s");
        tstr.Form(fmt, prop.GetLabel().Data(), prop.GetValue(), prop.GetUnit().Data());
      }
      str.Form("%03d - %s -@%d", idx, tstr.Data(), MRH_TMUSR_RUN_PHYSICAL_QUANTITY);
      tostr.SetString(str);
    }
  }
  // 5th check TStringVector
  for (UInt_t j=0; j<fStringVectorObj.size(); j++) {
    if (fStringVectorObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fStringVectorObj[j].GetPathName(), path, name);
      str.Form("%03d - %s: ", idx, name.Data());
      TStringVector vstr = fStringVectorObj[j].GetValue();
      for (UInt_t k=0; k<vstr.size()-1; k++)
        str += vstr[k] + "; ";
      str += vstr[vstr.size()-1];
      str += " -@";
      str += MRH_TSTRING_VECTOR;
      tostr.SetString(str);
    }
  }
  // 6th check TIntVector
  for (UInt_t j=0; j<fIntVectorObj.size(); j++) {
    if (fIntVectorObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fIntVectorObj[j].GetPathName(), path, name);
      str.Form("%03d - %s: ", idx, name.Data());
      TIntVector vint = fIntVectorObj[j].GetValue();
      for (UInt_t k=0; k<vint.size()-1; k++) {
        str += vint[k];
        str += "; ";
      }
      str += vint[vint.size()-1];
      str += " -@";
      str += MRH_INT_VECTOR;
      tostr.SetString(str);
    }
  }
  // 7th check TDoubleVector
  for (UInt_t j=0; j<fDoubleVectorObj.size(); j++) {
    if (fDoubleVectorObj[j].GetPathName() == fPathNameOrder[idx]) { // found correct object
      SplitPathName(fDoubleVectorObj[j].GetPathName(), path, name);
      str.Form("%03d - %s: ", idx, name.Data());
      TDoubleVector dvec = fDoubleVectorObj[j].GetValue();
      TString subStr("");
      fmt.Form("%%.%dlf", MRH_DOUBLE_PREC);
      for (UInt_t k=0; k<dvec.size()-1; k++) {
        subStr.Form(fmt, dvec[k]);
        str += subStr;
        str += "; ";
      }
      subStr.Form(fmt, dvec[dvec.size()-1]);
      str += subStr;
      str += " -@";
      str += MRH_DOUBLE_VECTOR;
      tostr.SetString(str);
    }
  }
 
  return tostr;
}
 
//--------------------------------------------------------------------------
// RemoveFirst (private)
//--------------------------------------------------------------------------
bool TMusrRunHeader::RemoveFirst(TString &str, const char splitter)
{
  Ssiz_t idx = str.First(splitter);
  if (idx == -1)
    return false;
 
  str.Remove(0, idx+1);
 
  return true;
}
 
//--------------------------------------------------------------------------
// GetFirst (private)
//--------------------------------------------------------------------------
TString TMusrRunHeader::GetFirst(TString &str, const char splitter)
{
  TString result = str;
 
  Ssiz_t idx = str.First(splitter);
  if (idx != -1)
    result.Remove(idx, str.Length());
 
  return result;
}
 
// end ---------------------------------------------------------------------