LorentShiftHierarchy Class Reference

1D Hierarchy for Lorentz shift correction More...

#include <Hierarchy.h>

Inheritance diagram for LorentShiftHierarchy:

Collaboration diagram for LorentShiftHierarchy:

Public Member Functions
	LorentShiftHierarchy ()
	Constructor.
std::vector< int >	getElementLabels (DetectorLevelElement element) final
	Label for Lorentz shift parameter.
template<class LowestLevelDBObject >
GlobalDerivativeSet	getGlobalDerivatives (unsigned short sensor, const genfit::StateOnPlane *sop, B2Vector3D bField)
	Template function to get globals for given db object and its element (and the rest of hierarchy)
TMatrixD	getLorentzShiftDerivatives (const genfit::StateOnPlane *sop, B2Vector3D bField)
	Derivatives for Lorentz shift in sensor plane.
template<class ChildDBObjectType , class MotherDBObjectType >
void	insertRelation (unsigned short child, unsigned short mother)
	Template function to insert hierarchy relation between two DB objects and their elements.
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
const std::set< unsigned short > &	getUsedDBObjUniqueIDs ()
	Get the global unique ids of DB objects used to construct hierarchy Useful 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

1D Hierarchy for Lorentz shift correction

Definition at line 108 of file Hierarchy.h.

Constructor & Destructor Documentation

LorentShiftHierarchy()

LorentShiftHierarchy ( )

inline

Constructor.

Definition at line 111 of file Hierarchy.h.

: GlobalDerivativesHierarchy() {};

Member Function Documentation

buildConstraints()

void buildConstraints ( Constraints &  constraints )

inherited

Adds constraints from current hierarchy to a constraints vector.

Definition at line 24 of file Hierarchy.cc.

    {
      for (auto& parent_children : m_hierarchy) {
        auto parent = parent_children.first;
        auto children = parent_children.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 transformation to its children are unchanged. While if (some of) the children 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 below...
        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 < children.size(); j++) {
            auto child = children[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  )

inherited

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 )

privateinherited

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()

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

finalvirtual

Label for Lorentz shift parameter.

Implements GlobalDerivativesHierarchy.

Definition at line 137 of file Hierarchy.cc.

    {
      std::vector<int> labels;
      GlobalLabel label;
      label.construct(element.first, element.second, 0);
      // TODO: constants instead of numbers
      labels.push_back(label.setParameterId(20));
 
      return labels;
    }

getGlobalDerivatives()

GlobalDerivativeSet getGlobalDerivatives ( unsigned short  sensor, const genfit::StateOnPlane *  sop, B2Vector3D  bField  )

inline

Template function to get globals for given db object and its element (and the rest of hierarchy)

Definition at line 118 of file Hierarchy.h.

      {
        if (bField.Mag() < 1.e-10)
          return std::make_pair(std::vector<int>(), TMatrixD());
 
        DetectorLevelElement elementUID = std::make_pair(LowestLevelDBObject::getGlobalUniqueID(), sensor);
 
        GlobalDerivativeSet sensorDerivs = std::make_pair(getElementLabels(elementUID), getLorentzShiftDerivatives(sop, bField));
        mergeGlobals(sensorDerivs, buildGlobalDerivativesHierarchy(getLorentzShiftDerivatives(sop, bField), elementUID));
        return sensorDerivs;
      }

getLorentzShiftDerivatives()

TMatrixD getLorentzShiftDerivatives	(	const genfit::StateOnPlane *	sop,
		B2Vector3D	bField
	)

Derivatives for Lorentz shift in sensor plane.

Definition at line 148 of file Hierarchy.cc.

    {
      // values for global derivatives
      //TMatrixD derGlobal(2, 6);
      TMatrixD derGlobal(2, 1);
      derGlobal.Zero();
 
      // electrons in device go in local w-direction to P-side
      B2Vector3D v = sop->getPlane()->getNormal();
      // Lorentz force (without E-field) direction
      B2Vector3D F_dir = v.Cross(bField);
      // ... projected to sensor coordinates:
      genfit::StateOnPlane localForce = *sop;
      localForce.setPosMom(sop->getPos(), F_dir);
      B2Vector3D lorentzLocal(localForce.getState()[3], localForce.getState()[4], 0); // or 0,1?
      // Lorentz shift = parameter(layer) * B_local
      derGlobal(0, 0) = lorentzLocal(0);
      derGlobal(1, 0) = lorentzLocal(1);
 
      return derGlobal;
    }

getUsedDBObjUniqueIDs()

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

inlineinherited

Get the global unique ids of DB objects used to construct hierarchy Useful 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  )

inlineinherited

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 element's 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;
        }
      }

insertRelation()

void insertRelation ( unsigned short  child, unsigned short  mother  )

inline

Template function to insert hierarchy relation between two DB objects and their elements.

Definition at line 135 of file Hierarchy.h.

      {
        insert<ChildDBObjectType, MotherDBObjectType>(child, mother, TMatrixD(1, 1).UnitMatrix());
      }

mergeGlobals()

void mergeGlobals ( GlobalDerivativeSet &  main, GlobalDerivativeSet  additional  )

staticinherited

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 ( )

inherited

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

privateinherited

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

privateinherited

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 {}

privateinherited

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