calibration

Modules
	calibration data objects
	calibration modules

Classes
class	MergeableNamed
	Abstract base class for objects that can be merged but also named. More...
class	TestCalibMean
	Test DBObject. More...
class	TestCalibObject
	Test DBObject. More...
class	TestBoundarySettingAlgorithm
	Test class implementing calibration algorithm. More...
class	TestCalibrationAlgorithm
	Test class implementing calibration algorithm. More...
class	TestDBAccessAlgorithm
	Test class implementing calibration algorithm. More...
class	CalibObjManager
	Manager class for collector registered data. Handles much of the TDirectory/TObject manipulation. More...
class	CalibrationAlgorithm
	Base class for calibration algorithms. More...
class	CalibrationCollectorModule
	Calibration collector module base class. More...
class	DBObjCalibrationConstMapBase
	Base for calibration or alignment parameters identified by two unsigned shorts Typically first is some identifier of a sub-detector element (sensor, layer, wire, board...) and the second is number of parameter. More...

Functions
template<>
TTree *	cloneObj (TTree *source, const std::string &newName) const
	Template specialization for TTree needs to be defined here to prevent automatic specialization being created.
template<class T >
std::shared_ptr< T >	getObjectPtr (const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
	Get calibration data object by name and list of runs, the Merge function will be called to generate the overall object.
template<>
std::shared_ptr< TTree >	getObjectPtr (const std::string &name, const std::vector< Calibration::ExpRun > &requestedRuns)
	Specialization of getObjectPtr<TTree>.
void	deleteHeldObjects ()
	Clears the map of templated objects -> causing their destruction.
void	addObject (const std::string &name, std::shared_ptr< TNamed > object)
	Add a new object to manage, this is used as a template for creating future/missing objects.
void	createDirectories ()
	Each object gets its own TDirectory under the main manager directory to store its objects.
void	createExpRunDirectories (Calibration::ExpRun &expRun) const
	For each templated object, we create a new TDirectory for this exprun.
void	writeCurrentObjects (const Calibration::ExpRun &expRun)
	For each templated object we know about, we find an in memory object for this exprun and write to the TDirectory.
void	clearCurrentObjects (const Calibration::ExpRun &expRun)
	Deletes all in-memory objects in the exprun directories for all the collector objects we know about.
unsigned int	getHighestIndexObject (const std::string &name, const TDirectory *dir) const
	Scans the directory to get the highest "_i" index of an object with this name.
std::string	getSuffix (const Calibration::ExpRun &key) const
	We rename objects based on the Exp,Run that they contain so we need to generate a nice naming convention.
std::string	getSuffix (const EventMetaData &emd) const
	Sometimes it's nice to just pass in the EventMetaData instead of converting manually.
std::string	getObjectExpRunName (const std::string &name, const Calibration::ExpRun &expRun) const
	Get object experiment and run name.
unsigned int	extractKeyIndex (const std::string &keyName) const
	Extract key index.
bool	isRegistered (const std::string &name) const
	Checks for the existence of a name in the templated object map to see if we registered the object.
template<>
shared_ptr< TTree >	getObjectPtr (const string &name, const vector< ExpRun > &requestedRuns)
	We cheekily cast the TChain to TTree for the returned pointer so that the user never knows Hopefully this doesn't cause issues if people do low level stuff to the tree...

Detailed Description

Function Documentation

addObject()

void addObject	(	const std::string &	name,
		std::shared_ptr< TNamed >	object
	)

Add a new object to manage, this is used as a template for creating future/missing objects.

We take ownership of this object but cannot guarantee that a user won't alter the wrapped ROOT object :(

Definition at line 40 of file CalibObjManager.cc.

  {
    if (m_templateObjects.find(name) != m_templateObjects.end()) {
      m_templateObjects[name].reset();
    }
    m_templateObjects[name] = object;
  }

clearCurrentObjects()

void clearCurrentObjects

(

const Calibration::ExpRun &

expRun

)

Deletes all in-memory objects in the exprun directories for all the collector objects we know about.

Definition at line 89 of file CalibObjManager.cc.

  {
    for (auto& x : m_templateObjects) {
      TDirectory* objectDir = m_dir->GetDirectory((x.first + '/' + getObjectExpRunName(x.first, expRun)).c_str());
      B2DEBUG(100, "We are deleting all the in-memory + file objects " << objectDir->GetPath());
      objectDir->DeleteAll();
    }
  }

cloneObj()

TTree * cloneObj	(	TTree *	source,
		const std::string &	newName
	)		const

Template specialization for TTree needs to be defined here to prevent automatic specialization being created.

Definition at line 25 of file CalibObjManager.cc.

  {
    B2DEBUG(100, "Held object is a TTree which will be have CloneTree() called.");
    // Construct the TTree by making a copy
    // of the source TTree
    TTree* dest = source->CloneTree(0);
    dest->SetName(newName.c_str());
    return dest;
  }

createDirectories()

void createDirectories

(

)

Each object gets its own TDirectory under the main manager directory to store its objects.

We create them using this function.

Definition at line 48 of file CalibObjManager.cc.

  {
    for (auto& x : m_templateObjects) {
      if (m_dir->GetDirectory(x.first.c_str()) == 0) {
        m_dir->mkdir(x.first.c_str());
        TDirectory* objectDir = m_dir->GetDirectory(x.first.c_str());
        objectDir->SetWritable(true);
        B2DEBUG(100, "Made TDirectory: " << x.first);
      }
    }
  }

createExpRunDirectories()

void createExpRunDirectories

(

Calibration::ExpRun &

expRun

)

const

For each templated object, we create a new TDirectory for this exprun.

Definition at line 60 of file CalibObjManager.cc.

  {
    for (auto& x : m_templateObjects) {
      TDirectory* objectDir = m_dir->GetDirectory(x.first.c_str());
      string dirName = x.first + getSuffix(expRun);
      TDirectory* newDir = objectDir->GetDirectory(dirName.c_str());
      if (!newDir) {
        newDir = objectDir->mkdir(dirName.c_str());
        newDir->SetWritable(true);
        B2DEBUG(100, "Made TDirectory " << newDir->GetPath());
      }
    }
  }

deleteHeldObjects()

void deleteHeldObjects

(

)

Clears the map of templated objects -> causing their destruction.

Definition at line 35 of file CalibObjManager.cc.

  {
    m_templateObjects.clear();
  }

extractKeyIndex()

unsigned int extractKeyIndex ( const std::string &  keyName ) const

private

Extract key index.

Definition at line 143 of file CalibObjManager.cc.

  {
    vector<string> strs;
    boost::split(strs, keyName, boost::is_any_of("_"));
    string indexString = strs.back();
    return stoi(indexString);
  }

getHighestIndexObject()

unsigned int getHighestIndexObject	(	const std::string &	name,
		const TDirectory *	dir
	)		const

Scans the directory to get the highest "_i" index of an object with this name.

Definition at line 98 of file CalibObjManager.cc.

  {
    unsigned int index = 0;
    // Try from the list of objects
    for (auto key : * (dir->GetList())) {
      string keyName = key->GetName();
      if (keyName.find(name) != std::string::npos) {
        B2DEBUG(1000, "Found previous Object " << keyName << " in the directory " << dir->GetPath());
        unsigned int currentIndex = extractKeyIndex(keyName);
        if (currentIndex > index) {
          index = currentIndex;
        }
      }
    }
    // Try from List of keys
    for (auto key : * (dir->GetListOfKeys())) {
      string keyName = key->GetName();
      if (keyName.find(name) != std::string::npos) {
        B2DEBUG(1000, "Found previous Key " << keyName << " in the directory " << dir->GetPath());
        unsigned int currentIndex = extractKeyIndex(keyName);
        if (currentIndex > index) {
          index = currentIndex;
        }
      }
    }
    B2DEBUG(1000, "Returning highest index " << index);
    return index;
  }

getObjectExpRunName()

string getObjectExpRunName ( const std::string &  name, const Calibration::ExpRun &  expRun  ) const

private

Get object experiment and run name.

Definition at line 138 of file CalibObjManager.cc.

  {
    return name + getSuffix(expRun);
  }

getObjectPtr() [1/2]

std::shared_ptr< T > getObjectPtr ( const std::string &  name, const std::vector< Calibration::ExpRun > &  requestedRuns  )

protected

Get calibration data object by name and list of runs, the Merge function will be called to generate the overall object.

Definition at line 414 of file CalibrationAlgorithm.h.

  {
    // Check if this object already exists
    RunRange runRangeRequested(requestedRuns);
    std::shared_ptr<T> objOutputPtr = std::dynamic_pointer_cast<T>(m_data.getCalibObj(name, runRangeRequested));
    if (objOutputPtr)
      return objOutputPtr;
 
    std::shared_ptr<T> mergedObjPtr(nullptr);
    bool mergedEmpty = true;
    TDirectory* dir = gDirectory;
 
    // Technically we could grab all the objects from all files, add to list and then merge at the end.
    // But I prefer the (maybe) more memory efficient way of merging with all objects
    // in a file before moving on to the next one, just in case TDirectory stuff screws us.
    TList list;
    list.SetOwner(false);
 
    // Construct the TDirectory names where we expect our objects to be
    std::string runRangeObjName(getPrefix() + "/" + Calibration::RUN_RANGE_OBJ_NAME);
 
    if (strcmp(getGranularity().c_str(), "run") == 0) {
      // Loop over our runs requested for the right files
      for (auto expRunRequested : requestedRuns) {
        // Find the relevant files for this ExpRun
        auto searchFiles = m_runsToInputFiles.find(expRunRequested);
        if (searchFiles == m_runsToInputFiles.end()) {
          B2WARNING("No input file found with data collected from run "
                    "(" << expRunRequested.first << "," << expRunRequested.second << ")");
          continue;
        } else {
          auto files = searchFiles->second;
          for (auto fileName : files) {
            RunRange* runRangeData;
            //Open TFile to get the objects
            std::unique_ptr<TFile> f;
            f.reset(TFile::Open(fileName.c_str(), "READ"));
            runRangeData = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
            // Check that nothing went wrong in the mapping and that this file definitely contains this run's data
            auto runSet = runRangeData->getExpRunSet();
            if (runSet.find(expRunRequested) == runSet.end()) {
              B2WARNING("Something went wrong with the mapping of ExpRun -> Input Files. "
                        "(" << expRunRequested.first << "," << expRunRequested.second << ") not in " << fileName);
            }
            // Get the path/directory of the Exp,Run TDirectory that holds the object(s)
            std::string objDirName = getFullObjectPath(name, expRunRequested);
            TDirectory* objDir = f->GetDirectory(objDirName.c_str());
            if (!objDir) {
              B2ERROR("Directory for requested object " << name << " not found: " << objDirName);
              return nullptr;
            }
            // Find all the objects inside, there may be more than one
            for (auto key : * (objDir->GetListOfKeys())) {
              std::string keyName = key->GetName();
              B2DEBUG(100, "Adding found object " << keyName << " in the directory " << objDir->GetPath());
              T* objOther = (T*)objDir->Get(keyName.c_str());
              if (objOther) {
                if (mergedEmpty) {
                  mergedObjPtr = std::shared_ptr<T>(dynamic_cast<T*>(objOther->Clone(name.c_str())));
                  mergedObjPtr->SetDirectory(0);
                  mergedEmpty = false;
                } else {
                  list.Add(objOther);
                }
              }
            }
            if (!mergedEmpty)
              mergedObjPtr->Merge(&list);
            list.Clear();
          }
        }
      }
    } else {
      for (auto fileName : m_inputFileNames) {
        //Open TFile to get the objects
        std::unique_ptr<TFile> f;
        f.reset(TFile::Open(fileName.c_str(), "READ"));
        Calibration::ExpRun allGranExpRun = getAllGranularityExpRun();
        std::string objDirName = getFullObjectPath(name, allGranExpRun);
        std::string objPath = objDirName + "/" + name + "_1";
        T* objOther = (T*)f->Get(objPath.c_str()); // Only one index for granularity == all
        B2DEBUG(100, "Adding " << objPath);
        if (objOther) {
          if (mergedEmpty) {
            mergedObjPtr = std::shared_ptr<T>(dynamic_cast<T*>(objOther->Clone(name.c_str())));
            mergedObjPtr->SetDirectory(0);
            mergedEmpty = false;
          } else {
            list.Add(objOther);
          }
        }
        if (!mergedEmpty)
          mergedObjPtr->Merge(&list);
        list.Clear();
      }
    }
    dir->cd();
    objOutputPtr = mergedObjPtr;
    if (!objOutputPtr) {
      B2ERROR("No data found for object " << name);
      return nullptr;
    }
    objOutputPtr->SetDirectory(0);
    // make a TNamed version to input to the map of previous calib objects
    std::shared_ptr<TNamed> storedObjPtr = std::static_pointer_cast<TNamed>(objOutputPtr);
    m_data.setCalibObj(name, runRangeRequested, storedObjPtr);
    B2DEBUG(100, "Passing back merged data " << name);
    return objOutputPtr;
  }

getObjectPtr() [2/2]

shared_ptr< TTree > getObjectPtr ( const string &  name, const vector< ExpRun > &  requestedRuns  )

protected

We cheekily cast the TChain to TTree for the returned pointer so that the user never knows Hopefully this doesn't cause issues if people do low level stuff to the tree...

Definition at line 520 of file CalibrationAlgorithm.cc.

  {
    // Check if this object already exists
    RunRange runRangeRequested(requestedRuns);
    std::shared_ptr<TTree> objOutputPtr = std::dynamic_pointer_cast<TTree>(m_data.getCalibObj(name, runRangeRequested));
    if (objOutputPtr)
      return objOutputPtr;
 
    // If not we best make a new one
    shared_ptr<TChain> chain = make_shared<TChain>(name.c_str());
    chain->SetDirectory(0);
    // Construct the TDirectory names where we expect our objects to be
    string runRangeObjName(getPrefix() + "/" + RUN_RANGE_OBJ_NAME);
 
    if (strcmp(getGranularity().c_str(), "run") == 0) {
      // Loop over our runs requested for the right files
      for (auto expRunRequested : requestedRuns) {
        // Find the relevant files for this ExpRun
        auto searchFiles = m_runsToInputFiles.find(expRunRequested);
        if (searchFiles == m_runsToInputFiles.end()) {
          B2WARNING("No input file found with data collected from run "
                    "(" << expRunRequested.first << "," << expRunRequested.second << ")");
          continue;
        } else {
          auto files = searchFiles->second;
          for (auto fileName : files) {
            RunRange* runRangeData;
            //Open TFile to get the objects
            std::unique_ptr<TFile> f;
            f.reset(TFile::Open(fileName.c_str(), "READ"));
            runRangeData = dynamic_cast<RunRange*>(f->Get(runRangeObjName.c_str()));
            // Check that nothing went wrong in the mapping and that this file definitely contains this run's data
            auto runSet = runRangeData->getExpRunSet();
            if (runSet.find(expRunRequested) == runSet.end()) {
              B2WARNING("Something went wrong with the mapping of ExpRun -> Input Files. "
                        "(" << expRunRequested.first << "," << expRunRequested.second << ") not in " << fileName);
            }
            // Get the path/directory of the Exp,Run TDirectory that holds the object(s)
            std::string objDirName = getFullObjectPath(name, expRunRequested);
            TDirectory* objDir = f->GetDirectory(objDirName.c_str());
            if (!objDir) {
              B2ERROR("Directory for requested object " << name << " not found: " << objDirName);
              return nullptr;
            }
            // Find all the objects inside, there may be more than one
            for (auto key : * (objDir->GetListOfKeys())) {
              string keyName = key->GetName();
              string objectPath = fileName + "/" + objDirName + "/" + keyName;
              B2DEBUG(29, "Adding TTree " << objectPath);
              chain->Add(objectPath.c_str());
            }
          }
        }
      }
    } else {
      ExpRun allGranExpRun = getAllGranularityExpRun();
      string objDirName = getFullObjectPath(name, allGranExpRun);
      for (const auto& fileName : m_inputFileNames) {
        string objectPath = fileName + "/" + objDirName + "/" + name + "_1";  // Only one index for this granularity
        B2DEBUG(29, "Adding TTree " << objectPath);
        chain->Add(objectPath.c_str());
      }
    }
    if (!chain->GetListOfFiles()->GetEntries()) {
      B2ERROR("No data found for object " << name);
      return nullptr;
    }
    objOutputPtr = static_pointer_cast<TTree>(chain);
    // make a TNamed version to input to the map of previous calib objects
    shared_ptr<TNamed> storedObjPtr = static_pointer_cast<TNamed>(objOutputPtr);
    m_data.setCalibObj(name, runRangeRequested, storedObjPtr);
    B2DEBUG(29, "Passing back merged data " << name);
    return objOutputPtr;
  }

getSuffix() [1/2]

string getSuffix ( const Calibration::ExpRun &  key ) const

private

We rename objects based on the Exp,Run that they contain so we need to generate a nice naming convention.

Definition at line 127 of file CalibObjManager.cc.

  {
    return "_" + encodeExpRun(expRun);
  }

getSuffix() [2/2]

string getSuffix ( const EventMetaData &  emd ) const

private

Sometimes it's nice to just pass in the EventMetaData instead of converting manually.

Definition at line 132 of file CalibObjManager.cc.

  {
    const ExpRun key = make_pair(emd.getExperiment(), emd.getRun());
    return getSuffix(key);
  }

isRegistered()

bool isRegistered

(

const std::string &

name

)

const

Checks for the existence of a name in the templated object map to see if we registered the object.

Definition at line 151 of file CalibObjManager.cc.

  {
    if (m_templateObjects.count(name)) return true;
    else return false;
  }

writeCurrentObjects()

void writeCurrentObjects

(

const Calibration::ExpRun &

expRun

)

For each templated object we know about, we find an in memory object for this exprun and write to the TDirectory.

Definition at line 74 of file CalibObjManager.cc.

  {
    for (auto& x : m_templateObjects) {
      TDirectory* objectDir = m_dir->GetDirectory((x.first + '/' + getObjectExpRunName(x.first, expRun)).c_str());
      B2DEBUG(100, "Writing for " << x.first);
      for (auto key : * (objectDir->GetList())) {
        B2DEBUG(100, "Writing for " << key->GetName());
        TNamed* objMemory = dynamic_cast<TNamed*>(objectDir->FindObject(key->GetName()));
        if (objMemory) {
          objectDir->WriteTObject(objMemory, key->GetName(), "Overwrite");
        }
      }
    }
  }