PXDIgnoredPixelsMap Class Reference

This class provides a check for ignored (=cold, hot or otherwise deffective) pixels for the use in PXD data reconstruction. More...

#include <PXDIgnoredPixelsMap.h>

Collaboration diagram for PXDIgnoredPixelsMap:

Public Types
typedef std::pair< unsigned short, unsigned short >	map_pixel
	Simple structure for a pixel, u = map_pixel.first, v = map_pixel.second.
typedef std::function< bool(unsigned short, unsigned short) >	pixel_range_test_prototype
	Prototype for lambda function used to check if a pixel is in masked range.
typedef std::multimap< unsigned int, pixel_range_test_prototype, std::greater< unsigned int > >	IgnoredPixelsRangeSet
	Structure to hold set of masked pixel ranges ordered from largest to smallest by their area (unsigned int)
typedef std::unordered_set< unsigned int >	IgnoredSinglePixelsSet
	Structure to hold set of masked single pixels indexed by their unique id (unsigned int), stored in hash table.

Public Member Functions
	PXDIgnoredPixelsMap (const std::string &xml_filename)
	Constructor. More...
	PXDIgnoredPixelsMap ()=delete
	No default constructor.
const std::set< map_pixel >	getIgnoredPixels (VxdID id)
	Get the set of ignored pixels for a sensor. More...
bool	pixelOK (VxdID id, map_pixel pixel)
	Check whether a pixel on a given sensor is OK or not. More...

Private Attributes
std::unordered_map< unsigned short, IgnoredPixelsRangeSet >	m_Map
	Structure holding sets of ignored pixel ranges for all sensors by sensor id (unsigned short).
std::unordered_map< unsigned short, IgnoredSinglePixelsSet >	m_MapSingles
	Structure holding sets of ingored single pixels for all sensors by sensor id (unsigned short).
IgnoredPixelsRangeSet	m_lastIgnored
	Set of ignored pixel ranges for the most currently queried sensor.
IgnoredSinglePixelsSet	m_lastIgnoredSingles
	Set of ignored single pixels for the most currently queried sensor.
VxdID	m_lastSensorID
	The most currently queried sensor number.
unsigned short	m_lastSensorVCells
	The most currently queried sensor number of V pixels (for quick pixel uid evaluation)

Detailed Description

This class provides a check for ignored (=cold, hot or otherwise deffective) pixels for the use in PXD data reconstruction.

The class has non-intrusive behavior, that is, it will not interfere when queries on non-existent sensors are asked. Treatment of single masked pixels and masked ranges (rows, cols, ...) is different for performance reasons.

NOTE: More optimization is possible:

• single rows and cols can go to hash tables (like pixels), as they can be uniquely identified. Then we would have m_MaskRows, m_MaskCols etc.
• lambdas for ranges of cols/rows can be simplified (2 less comparisons) or even
• instead hash tables, one could use directly vectors/arrays/std::bitset and only pixels, but with much more memory for map of all sensors (at least 8Mbit for whole Belle2 PXD & std::bitset)

Definition at line 39 of file PXDIgnoredPixelsMap.h.

Constructor & Destructor Documentation

PXDIgnoredPixelsMap()

PXDIgnoredPixelsMap ( const std::string &  xml_filename )

explicit

Constructor.

Parameters

xml_filename

is the name of the xml file containing the map.

Definition at line 20 of file PXDIgnoredPixelsMap.cc.

                                                                 :
  m_Map(0), m_MapSingles(0), m_lastSensorID(0), m_lastSensorVCells(0)
{
  // If the xmlFilename is empty, the user apparently doesn't want the map.
  // So keep low-profile, don't bother.
  if (xmlFilename == "") {
    B2DEBUG(10, "No xml list of ignored pixels specified.");
    return;
  }
  // Create an empty property tree object
 
  ptree propertyTree;
 
  // Load the XML file into the property tree. If reading fails
  // (cannot open file, parse error), an exception is thrown.
  string xmlFullPath = FileSystem::findFile(xmlFilename);
 
  if (! FileSystem::fileExists(xmlFullPath)) {
    B2WARNING("The xml filename: " << xmlFilename << endl <<
              "resolved to: " << xmlFullPath << endl <<
              "by FileSystem::findFile does not exist." << endl <<
              "PXD ignored pixels map cannot be initialized." << endl
             );
    return;
  }
 
  try {
    read_xml(xmlFullPath, propertyTree);
  } catch (std::exception const& ex) {
    B2WARNING("STD excpetion raised during xml parsing " << ex.what() << endl <<
              "PXD ignored pixels map cannot be initialized." << endl);
    return;
  } catch (...) {
    B2WARNING("Unknown excpetion raised during xml parsing "
              "PXD ignored pixels map cannot be initialized." << endl);
    return;
  }
 
  try {
    // traverse the xml tree: navigate through the daughters of <PXD>
    VxdID sensorID;
    for (ptree::value_type const& layer : propertyTree.get_child("PXD"))
      if (layer.first == "layer") {
        sensorID.setLayerNumber(static_cast<unsigned short>(layer.second.get<int>("<xmlattr>.n")));
        for (ptree::value_type const& ladder : layer.second)
          if (ladder.first == "ladder") {
            sensorID.setLadderNumber(static_cast<unsigned short>(ladder.second.get<int>("<xmlattr>.n")));
            for (ptree::value_type const& sensor : ladder.second)
              if (sensor.first == "sensor") {
                sensorID.setSensorNumber(static_cast<unsigned short>(sensor.second.get<int>("<xmlattr>.n")));
                PXDIgnoredPixelsMap::IgnoredPixelsRangeSet ranges;
                PXDIgnoredPixelsMap::IgnoredSinglePixelsSet singles;
                const VXD::SensorInfoBase& info = VXD::GeoCache::getInstance().get(sensorID);
                for (ptree::value_type const& tag : sensor.second) {
                  if (tag.first == "pixels") {
                    auto limits = tag.second;
                    // All possible attributes, default = -1 (att not present)
                    short uStart = limits.get<short>("<xmlattr>.uStart", -1);
                    short uEnd   = limits.get<short>("<xmlattr>.uEnd", -1);
                    short vStart = limits.get<short>("<xmlattr>.vStart", -1);
                    short vEnd   = limits.get<short>("<xmlattr>.vEnd", -1);
 
                    // Fill remaining range parameters
                    if (uStart != -1 && vStart != -1 && uEnd == -1 && vEnd == -1) {
                      // mask one pixel
                      uEnd = uStart;
                      vEnd = vStart;
                    } else if (uStart != -1 && vStart == -1 && uEnd == -1 && vEnd == -1) {
                      // mask column u ... all v rows
                      uEnd = uStart;
                      vStart = 0;
                      vEnd = info.getVCells() - 1;
                    } else if (uStart == -1 && vStart != -1 && uEnd == -1 && vEnd == -1) {
                      // mask row v ... all u columns
                      vEnd = vStart;
                      uStart = 0;
                      uEnd = info.getUCells() - 1;
                    } else if (uStart != -1 && vStart == -1 && uEnd != -1 && vEnd == -1) {
                      // columns from ... to ... (all rows there)
                      vStart = 0;
                      vEnd = info.getVCells() - 1;
                    } else if (uStart == -1 && vStart != -1 && uEnd == -1 && vEnd != -1) {
                      // rows from ... to ... (all columns there)
                      uStart = 0;
                      uEnd = info.getUCells() - 1;
                    } else if (uStart != -1 && vStart != -1 && uEnd != -1 && vEnd != -1) {
                      // already ok, rectangular area
                    } else {
                      // do not accept other combinations
                      continue;
                    }
                    // ensure positive and meaningfull values
                    unsigned short uS(uStart);
                    unsigned short vS(vStart);
                    unsigned short uE(uEnd);
                    unsigned short vE(vEnd);
                    if (uE >= info.getUCells()) uE = info.getUCells() - 1;
                    if (vE >= info.getVCells()) vE = info.getVCells() - 1;
                    if (vS > vE) vS = vE;
                    if (uS > uE) uS = uE;
                    // area of the masked range
                    unsigned int area = (uE - uS + 1) * (vE - vS + 1);
                    if (area == 1) {
                      // Single pixel masking:
                      // We store pixels by unique id in hash table
                      unsigned int uid = uStart * info.getVCells() + vStart;
                      // uid will be used to generate hash in unordered_set for quick access
                      singles.insert(uid);
                    } else {
                      // lambda function to decide if (u,v) is inside this range
                      PXDIgnoredPixelsMap::pixel_range_test_prototype range_mask =
                        [ = ](unsigned int u, unsigned int v) -> bool
                      { return (uS <= u && u <= uE && vS <= v && v <= vE); };
                      // area is used to sort ranges from largest to smallest
                      ranges.insert(std::make_pair(area, range_mask));
                    }
                  }
                }
                m_Map.insert(std::pair<unsigned short, PXDIgnoredPixelsMap::IgnoredPixelsRangeSet>(sensorID.getID(), ranges));
                m_MapSingles.insert(std::pair<unsigned short, PXDIgnoredPixelsMap::IgnoredSinglePixelsSet>(sensorID.getID(), singles));
              } // if sensor
          } // if ladder
      }  // if sensor
  } catch (...) {
    B2WARNING("Unknown exception raised during map initialization! "
              "PXD ignored pixels map may be corrupted." << endl);
    return;
  }
}

Member Function Documentation

getIgnoredPixels()

const std::set< PXDIgnoredPixelsMap::map_pixel > getIgnoredPixels

(

VxdID

id

)

Get the set of ignored pixels for a sensor.

Parameters

id	VxdID of the required sensor

Returns

the set of ignored pixels, and empty set for non-existent VxdID.

Definition at line 150 of file PXDIgnoredPixelsMap.cc.

pixelOK()

bool pixelOK	(	VxdID	id,
		PXDIgnoredPixelsMap::map_pixel	pixel
	)

Check whether a pixel on a given sensor is OK or not.

Parameters

id	VxdID of the sensor
pixel	Pixel constructed e.g. as map_pixel(u, v)

Returns

true if pixel or the id is not found in the list, otherwise false.

Definition at line 169 of file PXDIgnoredPixelsMap.cc.

---

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

• pxd/online/include/PXDIgnoredPixelsMap.h
• pxd/online/src/PXDIgnoredPixelsMap.cc