Belle II Software development
PXDClusterShape.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <pxd/reconstruction/PXDClusterShape.h>
10
11#include <pxd/geometry/SensorInfo.h>
12#include <pxd/reconstruction/ClusterProjection.h>
13
14#include <vxd/geometry/GeoCache.h>
15
16using namespace std;
17
18namespace Belle2 {
24 namespace PXD {
25
26 pxdClusterShapeDescr PXDClusterShape::pxdClusterShapeDescription = {
27 {pxdClusterShapeType::no_shape_set, "pxd cluster shape: no shape setting"},
28
29 {pxdClusterShapeType::shape_1, "pxd cluster shape: cluster 1x1 (single) pixel"},
30 {pxdClusterShapeType::shape_2_u, "pxd cluster shape: cluster 2x1 (u,v) pixels"},
31 {pxdClusterShapeType::shape_2_v, "pxd cluster shape: cluster 1x2 (u,v) pixels"},
32 {pxdClusterShapeType::shape_2_uv_diag, "pxd cluster shape: cluster 2x2 diagonal (u,v) pixels"},
33 {pxdClusterShapeType::shape_2_uv_antidiag, "pxd cluster shape: cluster 2x2 anti-diagonal (u,v) pixels"},
34 {pxdClusterShapeType::shape_N1, "pxd cluster shape: cluster Nx1 (u,v) pixels, N > 2"},
35 {pxdClusterShapeType::shape_1M, "pxd cluster shape: cluster 1xM (u,v) pixels, M > 2"},
36 {pxdClusterShapeType::shape_N2, "pxd cluster shape: cluster Nx2 (u,v) pixels, N > 2"},
37 {pxdClusterShapeType::shape_2M, "pxd cluster shape: cluster 2xM (u,v) pixels, M > 2"},
38 {pxdClusterShapeType::shape_4, "pxd cluster shape: cluster 2x2 (u,v) four pixels"},
39 {pxdClusterShapeType::shape_3_L, "pxd cluster shape: cluster 2x2 (u,v) three pixels: (L)"},
40 {pxdClusterShapeType::shape_3_L_mirr_u, "pxd cluster shape: cluster 2x2 (u,v) three pixels: (mirror_u_L)"},
41 {pxdClusterShapeType::shape_3_L_mirr_v, "pxd cluster shape: cluster 2x2 (u,v) three pixels: (mirror_v_L)"},
42 {pxdClusterShapeType::shape_3_L_mirr_uv, "pxd cluster shape: cluster 2x2 (u,v) three pixels: (mirror_u+v_L)"},
43 {pxdClusterShapeType::shape_large, "pxd cluster shape: larger cluster over 2 pixels in u and v"}
44
45 };
46
47 PXDClusterShape::~PXDClusterShape() {}
48
49
51 pxdClusterShapeType PXDClusterShape::setClsShape(const ClusterCandidate& cls, VxdID sensorID)
52 {
53 const SensorInfo& info = dynamic_cast<const SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
54 pxdClusterShapeType clsShape;
55 clsShape = pxdClusterShapeType::no_shape_set;
56 ClusterProjection projU, projV;
57 float fCategU = 0.0;
58 float fCategV = 0.0;
59 float fDiagU = 0.0;
60 float fDiagV = 0.0;
61 int CSFull = 0;
62 for (const PXD::Pixel& px : cls.pixels()) {
63 if (CSFull == 0) {
64 fDiagU = px.getU();
65 fDiagV = px.getV();
66 }
67 if (CSFull < 3) {
68 fCategU += px.getU();
69 fCategV += px.getV();
70 }
71 CSFull++;
72 projU.add(px.getU(), info.getUCellPosition(px.getU()), px.getCharge());
73 projV.add(px.getV(), info.getVCellPosition(px.getV()), px.getCharge());
74
75
76 }
77 projU.finalize();
78 projV.finalize();
79
80 if (CSFull == 1) {
81 clsShape = pxdClusterShapeType::shape_1; // 1x1 pixels
82 } else if (CSFull == 2) {
83 if ((projU.getSize() == 2) && (projV.getSize() == 1)) {
84 clsShape = pxdClusterShapeType::shape_2_u; // 2x1 (u,v) pixels
85 } else if ((projU.getSize() == 1) && (projV.getSize() == 2)) {
86 clsShape = pxdClusterShapeType::shape_2_v; // 1x2 (u,v) pixels
87 } else if ((fDiagU < (fCategU / 2.0)) && (fDiagV < (fCategV / 2.0))) {
88 clsShape = pxdClusterShapeType::shape_2_uv_diag; // 2x2 diagonal (u,v) pixels
89 } else {
90 clsShape = pxdClusterShapeType::shape_2_uv_antidiag; // 2x2 anti-diagonal (u,v) pixels
91 }
92 } else if (CSFull == 3) {
93 if ((projU.getSize() == 2) && (projV.getSize() == 2)) {
94 int MisU = 0; // missing pixel in "L" cluster - u marker
95 int MisV = 0; // missing pixel in "L" cluster - v marker
96 fCategU /= 3.0;
97 fCategV /= 3.0;
98 if ((fCategU - (int)fCategU) < 0.5) {
99 MisU = 1;
100 }
101 if ((fCategV - (int)fCategV) < 0.5) {
102 MisV = 1;
103 }
104 if ((MisU == 1) && (MisV == 1)) {
105 clsShape = pxdClusterShapeType::shape_3_L; // 2x2 (u,v) three pixels: o* (L)
106 // oo
107 } else if ((MisU == 0) && (MisV == 1)) {
108 clsShape = pxdClusterShapeType::shape_3_L_mirr_u; // 2x2 (u,v) three pixels: *o (mirror_u_L)
109 // oo
110 } else if ((MisU == 1) && (MisV == 0)) {
111 clsShape = pxdClusterShapeType::shape_3_L_mirr_v; // 2x2 (u,v) three pixels: oo (mirror_v_L)
112 // o*
113 } else if ((MisU == 0) && (MisV == 0)) {
114 clsShape = pxdClusterShapeType::shape_3_L_mirr_uv; // 2x2 (u,v) three pixels: oo (mirror_u+v_L)
115 // *o
116 }
117 } else if (projV.getSize() == 1) {
118 clsShape = pxdClusterShapeType::shape_N1; // Nx1 (u,v) pixels, N > 2
119 } else if (projU.getSize() == 1) {
120 clsShape = pxdClusterShapeType::shape_1M; // 1xM (u,v) pixels, M > 2
121 } else if (projV.getSize() == 2) {
122 clsShape = pxdClusterShapeType::shape_N2; // Nx2 (u,v) pixels, N > 2
123 } else if (projU.getSize() == 2) {
124 clsShape = pxdClusterShapeType::shape_2M; // 2xM (u,v) pixels, M > 2
125 } else {
126 clsShape = pxdClusterShapeType::shape_large; // big cluster over 2x2 pixels
127 }
128 } else if (CSFull == 4) {
129 if ((projU.getSize() == 2) && (projV.getSize() == 2)) {
130 clsShape = pxdClusterShapeType::shape_4; // 2x2 (u,v) four pixels
131 } else if (projV.getSize() == 1) {
132 clsShape = pxdClusterShapeType::shape_N1; // Nx1 (u,v) pixels, N > 2
133 } else if (projU.getSize() == 1) {
134 clsShape = pxdClusterShapeType::shape_1M; // 1xM (u,v) pixels, M > 2
135 } else if (projV.getSize() == 2) {
136 clsShape = pxdClusterShapeType::shape_N2; // Nx2 (u,v) pixels, N > 2
137 } else if (projU.getSize() == 2) {
138 clsShape = pxdClusterShapeType::shape_2M; // 2xM (u,v) pixels, M > 2
139 } else {
140 clsShape = pxdClusterShapeType::shape_large; // big cluster over 2x2 pixels
141 }
142 } else if (CSFull >= 5) {
143 if (projV.getSize() == 1) {
144 clsShape = pxdClusterShapeType::shape_N1; // Nx1 (u,v) pixels, N > 2
145 } else if (projU.getSize() == 1) {
146 clsShape = pxdClusterShapeType::shape_1M; // 1xM (u,v) pixels, M > 2
147 } else if (projV.getSize() == 2) {
148 clsShape = pxdClusterShapeType::shape_N2; // Nx2 (u,v) pixels, N > 2
149 } else if (projU.getSize() == 2) {
150 clsShape = pxdClusterShapeType::shape_2M; // 2xM (u,v) pixels, M > 2
151 } else {
152 clsShape = pxdClusterShapeType::shape_large; // big cluster over 2x2 pixels
153 }
154 }
155
156 return clsShape;
157 } //setClsShape
158
159 } //PXD namespace
161} //Belle2 namespace
Belle2::PXD::ClusterCandidate
Class representing a possible cluster during clustering of the PXD It supports merging of different c...
Definition: ClusterCandidate.h:30
Belle2::PXD::ClusterCandidate::pixels
const std::vector< Pixel > & pixels() const
get a reference to all pixels in the cluster
Definition: ClusterCandidate.h:83
Belle2::PXD::ClusterProjection
Helper struct to collect information about the 1D projection of a Pixel cluster.
Definition: ClusterProjection.h:26
Belle2::PXD::ClusterProjection::add
void add(unsigned int cell, float position, float charge)
Add Pixel information to the projection.
Definition: ClusterProjection.h:101
Belle2::PXD::ClusterProjection::finalize
void finalize()
Finish calculation of center of gravity and set correct cluster size.
Definition: ClusterProjection.h:43
Belle2::PXD::ClusterProjection::getSize
unsigned int getSize() const
Return the projected size of the cluster.
Definition: ClusterProjection.h:54
Belle2::PXD::PXDClusterShape::setClsShape
pxdClusterShapeType setClsShape(const ClusterCandidate &cls, VxdID sensorID)
Set cluster shape ID.
Definition: PXDClusterShape.cc:51
Belle2::PXD::PXDClusterShape::~PXDClusterShape
~PXDClusterShape()
Delete the cache and free the memory.
Definition: PXDClusterShape.cc:47
Belle2::PXD::PXDClusterShape::pxdClusterShapeDescription
static pxdClusterShapeDescr pxdClusterShapeDescription
Create detail description of cluster shape.
Definition: PXDClusterShape.h:89
Belle2::PXD::Pixel
Class to represent one pixel, used in clustering for fast access.
Definition: Pixel.h:36
Belle2::PXD::SensorInfo
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
Definition: SensorInfo.h:23
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a referecne to the SensorInfo of a given SensorID.
Definition: GeoCache.cc:67
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:214
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::PXD::pxdClusterShapeDescr
std::map< pxdClusterShapeType, std::string > pxdClusterShapeDescr
Type specifies cluster shape type description.
Definition: PXDClusterShape.h:43
Belle2::PXD::pxdClusterShapeType
pxdClusterShapeType
Type specifies cluster shape type.
Definition: PXDClusterShape.h:21
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.