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

#include <PXDIgnoredPixelsMap.h>

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.

	PXDIgnoredPixelsMap ()=delete
	No default constructor.

const std::set< map_pixel >	getIgnoredPixels (VxdID id)
	Get the set of ignored pixels for a sensor.

bool	pixelOK (VxdID id, map_pixel pixel)
	Check whether a pixel on a given sensor is OK or not.

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.

Member Typedef Documentation

◆ IgnoredPixelsRangeSet

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)

Definition at line 46 of file PXDIgnoredPixelsMap.h.

◆ IgnoredSinglePixelsSet

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.

Definition at line 48 of file PXDIgnoredPixelsMap.h.

◆ map_pixel

typedef std::pair<unsigned short, unsigned short> map_pixel

Simple structure for a pixel, u = map_pixel.first, v = map_pixel.second.

Definition at line 42 of file PXDIgnoredPixelsMap.h.

◆ pixel_range_test_prototype

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.

Definition at line 44 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().getSensorInfo(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.

{
  // Merely for testing...
  // This function is quite ineffective, but it is not supposed to be run often
  // Also, it currently returns copy of the (possibly very big) set of masked pixels
  std::set<PXDIgnoredPixelsMap::map_pixel> pixels;
  const VXD::SensorInfoBase& info = VXD::GeoCache::getInstance().getSensorInfo(id);
 
  // This is quite slow solution but it merges duplicate maskings in the set
  for (int pixelU = 0; pixelU < info.getUCells(); pixelU++) {
    for (int pixelV = 0; pixelV < info.getVCells(); pixelV++) {
      PXDIgnoredPixelsMap::map_pixel px(pixelU, pixelV);
      if (!pixelOK(id, px))
        pixels.insert(px);
    }
  }
  return pixels;
}

◆ 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.

{
  // If sensor id changed from last query, swich to temp maps
  // of the new sensor. Otherwise clear temp maps, as there is nothing to mask
  if (id != m_lastSensorID) {
    m_lastSensorID = id;
    m_lastSensorVCells = VXD::GeoCache::getInstance().getSensorInfo(m_lastSensorID).getVCells();
    auto mapIter = m_Map.find(id);
    auto mapIterSingles = m_MapSingles.find(id);
 
    if (mapIter != m_Map.end())
      m_lastIgnored = mapIter->second;
    else
      m_lastIgnored.clear();
 
    if (mapIterSingles != m_MapSingles.end())
      m_lastIgnoredSingles = mapIterSingles->second;
    else
      m_lastIgnoredSingles.clear();
 
    if (mapIter == m_Map.end() && mapIterSingles == m_MapSingles.end()) {
      // Sensor has no masked ranges or single pixels in the maps => pixel ok
      return true;
    }
  }
 
  const unsigned int u = pixel.first;
  const unsigned int v = pixel.second;
 
  // loop over masked ranges for the sensor
  // (iter over multimap ordered by masked area)
  for (auto iter = m_lastIgnored.begin(); iter != m_lastIgnored.end(); ++iter) {
    // call the lambda function of masked range to check if pixel is inside
    if (iter->second(u, v))
      return false;
  }
  // Look if this is a single masked pixel
  // (lookup in hash table)
  if (m_lastIgnoredSingles.find(u * m_lastSensorVCells + v) != m_lastIgnoredSingles.end())
    return false;
 
  // Pixel not found in the mask => pixel OK
  return true;
}

Member Data Documentation

◆ m_lastIgnored

IgnoredPixelsRangeSet m_lastIgnored

private

Set of ignored pixel ranges for the most currently queried sensor.

Definition at line 80 of file PXDIgnoredPixelsMap.h.

◆ m_lastIgnoredSingles

IgnoredSinglePixelsSet m_lastIgnoredSingles

private

Set of ignored single pixels for the most currently queried sensor.

Definition at line 82 of file PXDIgnoredPixelsMap.h.

◆ m_lastSensorID

VxdID m_lastSensorID

private

The most currently queried sensor number.

Definition at line 85 of file PXDIgnoredPixelsMap.h.

◆ m_lastSensorVCells

unsigned short m_lastSensorVCells

private

The most currently queried sensor number of V pixels (for quick pixel uid evaluation)

Definition at line 87 of file PXDIgnoredPixelsMap.h.

◆ m_Map

std::unordered_map<unsigned short, IgnoredPixelsRangeSet> m_Map

private

Structure holding sets of ignored pixel ranges for all sensors by sensor id (unsigned short).

Definition at line 75 of file PXDIgnoredPixelsMap.h.

◆ m_MapSingles

std::unordered_map<unsigned short, IgnoredSinglePixelsSet> m_MapSingles

private

Structure holding sets of ingored single pixels for all sensors by sensor id (unsigned short).

Definition at line 77 of file PXDIgnoredPixelsMap.h.

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

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

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ IgnoredPixelsRangeSet

◆ IgnoredSinglePixelsSet

◆ map_pixel

◆ pixel_range_test_prototype

Constructor & Destructor Documentation

◆ PXDIgnoredPixelsMap()

Member Function Documentation

◆ getIgnoredPixels()

◆ pixelOK()

Member Data Documentation

◆ m_lastIgnored

◆ m_lastIgnoredSingles

◆ m_lastSensorID

◆ m_lastSensorVCells

◆ m_Map

◆ m_MapSingles