GlobalDerivativesHierarchy Class Reference

Class for alignment/calibration parameter hierarchy & constraints. More...

#include <Hierarchy.h>

Inheritance diagram for GlobalDerivativesHierarchy:

Public Member Functions
	GlobalDerivativesHierarchy ()
	Constructor.
virtual	~GlobalDerivativesHierarchy ()
	Destructor (virtual)
void	buildConstraints (Constraints &constraints)
	Adds constraints from current hierarchy to a constraints vector.
GlobalDerivativeSet	buildGlobalDerivativesHierarchy (TMatrixD matrixChain, DetectorLevelElement child)
	Recursive function which adds labels and derivatives until top element in hierarchy is found.
template<class ChildDBObjectType , class MotherDBObjectType >
void	insert (unsigned short child, unsigned short mother, TMatrixD childToMotherParamTransform)
	Template function to add relation between two elements (possibly in different objects with constants) First object is the child object, second its hierarchy parent.
void	printHierarchy ()
	print the lookup map
virtual std::vector< int >	getElementLabels (DetectorLevelElement element)=0
	The only function to implement: what are the global labels for the element?
const std::set< unsigned short > &	getUsedDBObjUniqueIDs ()
	Get the global unique ids of DB objects used to construct hierarchy Usefull to update hierarchy only when those changed.

Static Public Member Functions
static void	mergeGlobals (GlobalDerivativeSet &main, GlobalDerivativeSet additional)
	Merge additional set into main set of global labels and derivatives TODO: move to some utilities.

Private Member Functions
std::pair< DetectorLevelElement, TMatrixD >	getChildToMotherTransform (DetectorLevelElement child)
	Find the transformation in the lookup.

Private Attributes
std::map< DetectorLevelElement, std::pair< DetectorLevelElement, TMatrixD > >	m_lookup
	Map with all the parameter data (child -> (mother, transform_child2mother))
std::map< DetectorLevelElement, std::vector< DetectorLevelElement > >	m_hierarchy
	Map of hierarchy relations mother-> child.
std::set< unsigned short >	m_usedUniqueIDs {}
	The set of unique id of each DB object used for construction For more efficient updates of hierarchy only when used objects change.

Detailed Description

Class for alignment/calibration parameter hierarchy & constraints.

Definition at line 41 of file Hierarchy.h.

Constructor & Destructor Documentation

GlobalDerivativesHierarchy()

GlobalDerivativesHierarchy ( )

inline

Constructor.

Definition at line 44 of file Hierarchy.h.

{}

~GlobalDerivativesHierarchy()

virtual ~GlobalDerivativesHierarchy ( )

inlinevirtual

Destructor (virtual)

Definition at line 46 of file Hierarchy.h.

{}

Member Function Documentation

buildConstraints()

void buildConstraints

(

Constraints &

constraints

)

Adds constraints from current hierarchy to a constraints vector.

Definition at line 24 of file Hierarchy.cc.

    {
      for (auto& parent_childs : m_hierarchy) {
        auto parent = parent_childs.first;
        auto childs = parent_childs.second;
 
        // We need to check if such constraint entry already exists.
        // For timedep parameters, some to all labels (and coefficients optionally, too) can change and
        // in such case, we need a new constraint entry.
        // Note the checksum for a constraint does not depend on the parent element. If parent object changes,
        // the relative transofrmation to its children are unchanged. While if (some of) the childs change,
        // for each time interval they are constant, there must a new constraint entry as this is an independent
        // linear combination of parameters (because there are other parameters).
        // Continued bellow...
        boost::crc_32_type crc32;
 
        auto parentLabels = getElementLabels(parent);
        for (unsigned int iCon = 0; iCon < parentLabels.size(); iCon++) {
          auto constraint = Constraint();
          //auto & constraint = constraints[parentLabels[iCon]];
 
          // No constraints if parent is global reference frame
          // All subdetectors are actually nominally placed at constant position and rotation
          // and rotating the detectors could only happen due cohherent movements of sub-structures (CDC layers, VXD half-shells)
          if (parentLabels[iCon] == 0) continue;
 
          for (unsigned int j = 0; j < childs.size(); j++) {
            auto child = childs[j];
            auto childLabels = getElementLabels(child);
 
            for (unsigned int iPar = 0; iPar < childLabels.size(); iPar++) {
              double coefficient = getChildToMotherTransform(child).second(iCon, iPar);
              if (fabs(coefficient) > 1.0e-14) {
                auto childLabel = childLabels[iPar];
                constraint.push_back(std::make_pair(childLabel, coefficient));
                // On the other hand, if the labels do not change, the checksum should not change.
                // In future I should add second checksum and warn user if this happens. It means user has ignored the fact,
                // that the objects already change in the input global tag. The point here is, it still might be reasonable
                // to use the constraint coefficients we already have, as the alignment changes are usually small and do not change
                // the constraint coefficients in first order for most use-cases. The warning should be enough -> TODO
                crc32.process_bytes(&childLabel, sizeof(childLabel));
              }
            }
          }
 
          //constraints.insert(std::make_pair(parentLabels[iCon], constraint));
          constraints.insert(std::make_pair(crc32.checksum(), constraint));
 
        }
      }
    }

buildGlobalDerivativesHierarchy()

Belle2::alignment::GlobalDerivativeSet buildGlobalDerivativesHierarchy	(	TMatrixD	matrixChain,
		DetectorLevelElement	child
	)

Recursive function which adds labels and derivatives until top element in hierarchy is found.

Definition at line 76 of file Hierarchy.cc.

    {
      auto loc2glo = getChildToMotherTransform(child);
 
      if (loc2glo.first == std::make_pair((unsigned short)0, (unsigned short)0))
        return std::make_pair(std::vector<int>(), TMatrixD());
 
 
      TMatrixD glo2loc(loc2glo.second.Invert());
      TMatrixD drdparent = matrixChain * glo2loc;
 
 
      GlobalDerivativeSet retVal = std::make_pair(getElementLabels(loc2glo.first), drdparent);
      mergeGlobals(retVal, buildGlobalDerivativesHierarchy(drdparent, loc2glo.first));
 
      return retVal;
    }

getChildToMotherTransform()

std::pair< Belle2::alignment::DetectorLevelElement, TMatrixD > getChildToMotherTransform ( DetectorLevelElement  child )

private

Find the transformation in the lookup.

Definition at line 125 of file Hierarchy.cc.

    {
      auto entry = m_lookup.find(child);
      if (entry == m_lookup.end())
        return std::make_pair(std::make_pair(0, 0), TMatrixD());
 
      return entry->second;
    }

getElementLabels()

virtual std::vector< int > getElementLabels ( DetectorLevelElement  element )

pure virtual

The only function to implement: what are the global labels for the element?

Implemented in LorentShiftHierarchy, and RigidBodyHierarchy.

getUsedDBObjUniqueIDs()

const std::set< unsigned short > & getUsedDBObjUniqueIDs ( )

inline

Get the global unique ids of DB objects used to construct hierarchy Usefull to update hierarchy only when those changed.

Definition at line 91 of file Hierarchy.h.

{return m_usedUniqueIDs;}

insert()

void insert ( unsigned short  child, unsigned short  mother, TMatrixD  childToMotherParamTransform  )

inline

Template function to add relation between two elements (possibly in different objects with constants) First object is the child object, second its hierarchy parent.

Parameters

child	is the lement numeric id in child obj
mother	is the parent object
childToMotherParamTransform	is the transformation matrix (placement from geometry of the detector)

Definition at line 60 of file Hierarchy.h.

      {
        auto childUID = std::make_pair(ChildDBObjectType::getGlobalUniqueID(), child);
        auto parentUID = std::make_pair(MotherDBObjectType::getGlobalUniqueID(), mother);
 
        if (m_lookup.insert(std::make_pair(childUID, std::make_pair(parentUID, childToMotherParamTransform))).second) {
          // Just inserted an child element (so each child is inserted exactly once)
          // Try to insert parent with empty vect (does nothing if parent already in map)
          m_hierarchy.insert(std::make_pair(parentUID, std::vector<DetectorLevelElement>()));
          // insert child (can happen only once, so the vect is unique)
          m_hierarchy[parentUID].push_back(childUID);
          m_usedUniqueIDs.insert(ChildDBObjectType::getGlobalUniqueID());
          m_usedUniqueIDs.insert(MotherDBObjectType::getGlobalUniqueID());
        } else {
          // Update element transformation if inserted again
          m_lookup[childUID].second = childToMotherParamTransform;
        }
      }

mergeGlobals()

void mergeGlobals ( GlobalDerivativeSet &  main, GlobalDerivativeSet  additional  )

static

Merge additional set into main set of global labels and derivatives TODO: move to some utilities.

Definition at line 95 of file Hierarchy.cc.

    {
      if (additional.first.empty())
        return;
 
      // Create composed matrix of derivatives
      //TODO: check main and additional matrix has the same number of rows
      TMatrixD allDerivatives(main.second.GetNrows(), main.second.GetNcols() + additional.second.GetNcols());
      allDerivatives.Zero();
      allDerivatives.SetSub(0, 0, main.second);
      allDerivatives.SetSub(0, main.second.GetNcols(), additional.second);
 
      // Merge labels
      main.first.insert(main.first.end(), additional.first.begin(), additional.first.end());
      // Update matrix
      main.second.ResizeTo(allDerivatives);
      main.second = allDerivatives;
 
    }

printHierarchy()

void printHierarchy

(

)

print the lookup map

Definition at line 116 of file Hierarchy.cc.

    {
      for (auto& entry : m_lookup) {
        std::cout << "Child  : " << entry.first.second << std::endl;
        std::cout << "Mother :" << entry.second.first.second << std::endl;
        entry.second.second.Print();
      }
    }

Member Data Documentation

m_hierarchy

std::map<DetectorLevelElement, std::vector<DetectorLevelElement> > m_hierarchy

private

Map of hierarchy relations mother-> child.

Definition at line 100 of file Hierarchy.h.

m_lookup

std::map<DetectorLevelElement, std::pair<DetectorLevelElement, TMatrixD> > m_lookup

private

Map with all the parameter data (child -> (mother, transform_child2mother))

Definition at line 98 of file Hierarchy.h.

m_usedUniqueIDs

std::set<unsigned short> m_usedUniqueIDs {}

private

The set of unique id of each DB object used for construction For more efficient updates of hierarchy only when used objects change.

Definition at line 104 of file Hierarchy.h.

---

The documentation for this class was generated from the following files:

• alignment/include/Hierarchy.h
• alignment/src/Hierarchy.cc