Belle II Software  release-05-01-25
HitColorMapping.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: dschneider, Oliver Frost *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 #include <tracking/trackFindingCDC/display/HitColorMapping.h>
11 #include <tracking/trackFindingCDC/display/Colors.h>
12 
13 #include <tracking/trackFindingCDC/mclookup/CDCMCHitLookUp.h>
14 #include <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
15 #include <tracking/trackFindingCDC/utilities/VectorRange.h>
16 
17 #include <cdc/dataobjects/CDCHit.h>
18 #include <cdc/dataobjects/CDCSimHit.h>
19 #include <mdst/dataobjects/MCParticle.h>
20 
21 #include <set>
22 #include <sstream>
23 
24 using namespace Belle2;
25 using namespace TrackFindingCDC;
26 
28 const std::string c_bkgHitColor = "orange";
29 
31 const std::string c_missingPDGColor = "lime";
32 
34 const std::map<int, std::string> c_colorByPDGCode = {
35  { -999, "orange"},
36  {11, "blue"},
37  { -11, "blue"},
38  {13, "turquoise"},
39  { -13, "turquoise"},
40  {15, "cyan"},
41  { -15, "cyan"},
42  {22, "violet"},
43  {211, "green"},
44  { -211, "green"},
45  {321, "olive"},
46  { -321, "olive"},
47  {2212, "red"},
48  { -2212, "red"},
49 };
50 
51 std::string ZeroDriftLengthColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
52 {
53  CDCWireHit wirehit(&hit);
54  if (wirehit.getRefDriftLength() == 0) {
55  return "red";
56  } else {
57  return c_bkgHitColor;
58  }
59 }
60 
61 std::string ZeroDriftLengthStrokeWidthMap::map(int index __attribute__((unused)), const CDCHit& hit)
62 {
63  CDCWireHit wirehit(&hit, nullptr);
64  if (wirehit.getRefDriftLength() == 0) {
65  return "1";
66  } else {
67  return "0.2";
68  }
69 }
70 
72 {
73  if (not m_storedWireHits) {
74  B2WARNING("CDCWireHitVector could not be found on the DataStore. Cannot plot the taken flags.");
75  }
76 }
77 
78 std::string TakenFlagColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
79 {
80  if (m_storedWireHits) {
81  const std::vector<CDCWireHit>& wireHits = *m_storedWireHits;
82  ConstVectorRange<CDCWireHit> wireHitRange{std::equal_range(wireHits.begin(), wireHits.end(), hit)};
83 
84  if (not wireHitRange.empty()) {
85  const CDCWireHit& wireHit = wireHitRange.front();
86  if (wireHit.getAutomatonCell().hasTakenFlag()) {
87  return "red";
88  }
89  }
90  }
91  return c_bkgHitColor;
92 }
93 
94 std::string RLColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
95 {
96  const CDCMCHitLookUp& mcHitLookUp = mcHitLookUp.getInstance();
97  short int rlInfo = mcHitLookUp.getRLInfo(&hit);
98  if (rlInfo == 1) {
99  return ("green");
100  } else if (rlInfo == -1) {
101  return ("red");
102  } else {
103  return (c_bkgHitColor);
104  }
105 }
106 
107 std::string RLColorMap::info()
108 {
109  return "Local right left passage variable: green <-> right, red <-> left, orange <-> not determinable.\n";
110 }
111 
112 std::string PosFlagColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
113 {
114  CDCSimHit* simHit = hit.getRelated<CDCSimHit>("CDCSimHits");
115  int posFlag = simHit->getPosFlag();
116  if (posFlag == 0) {
117  return ("green"); // right
118  } else if (posFlag == 1) {
119  return ("red"); // left
120  } else {
121  return (c_bkgHitColor);
122  }
123 }
124 
126 {
127  return "PosFlag variable of the related CDCSimHit: green <-> 0 (Right), red <-> 1 (Left), orange <-> determinable.\n";
128 }
129 
130 std::string BackgroundTagColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
131 {
132  CDCSimHit* cdcSimHit = hit.getRelated<CDCSimHit>("CDCSimHits");
133  short backgroundtag = cdcSimHit->getBackgroundTag();
134  switch (backgroundtag) {
135  case BackgroundMetaData::BG_TAG::bg_none: return "orange";
136  case BackgroundMetaData::BG_TAG::bg_Coulomb_LER: return "red";
137  case BackgroundMetaData::BG_TAG::bg_Coulomb_HER: return "darkred";
138  case BackgroundMetaData::BG_TAG::bg_RBB_LER: return "blue";
139  case BackgroundMetaData::BG_TAG::bg_RBB_HER: return "darkblue";
140  case BackgroundMetaData::BG_TAG::bg_Touschek_LER: return "green";
141  case BackgroundMetaData::BG_TAG::bg_Touschek_HER: return "darkgreen";
142  case BackgroundMetaData::BG_TAG::bg_twoPhoton: return "violet";
143  case BackgroundMetaData::BG_TAG::bg_RBB_gamma: return "skyblue";
144  case BackgroundMetaData::BG_TAG::bg_RBB_LER_far: return "turquoise";
145  case BackgroundMetaData::BG_TAG::bg_RBB_HER_far: return "darkturquoise";
146  case BackgroundMetaData::BG_TAG::bg_Touschek_LER_far: return "olivergreen";
147  case BackgroundMetaData::BG_TAG::bg_Touschek_HER_far: return "darkolivegreen";
148  case BackgroundMetaData::BG_TAG::bg_SynchRad_LER: return "goldenrod";
149  case BackgroundMetaData::BG_TAG::bg_SynchRad_HER: return "darkgoldenrod";
150  case BackgroundMetaData::BG_TAG::bg_BHWide_LER: return "cyan";
151  case BackgroundMetaData::BG_TAG::bg_BHWide_HER: return "darkcyan";
152  case BackgroundMetaData::BG_TAG::bg_other: return "orange";
153  default:
154  B2INFO("Background tag " << backgroundtag << " not associated with a color.\n");
155  return ("orange");
156  }
157 }
158 
160 {
161  return ("Background tag color coding is:\n"
162  "bg_Coulomb_HER: darkred\n"
163  "bg_Coulomb_LER: red\n"
164  "bg_RBB_HER: darkblue\n"
165  "bg_RBB_HER_far: darkturquoise\n"
166  "bg_RBB_LER: blue\n"
167  "bg_RBB_LER_far: turquoise\n"
168  "bg_SynchRad_HER: darkgoldenrod\n"
169  "bg_SynchRad_LER: goldenrod\n"
170  "bg_Touschek_HER: darkgreen\n"
171  "bg_Touschek_HER_far: darkolivegreen\n"
172  "bg_Touschek_LER: green\n"
173  "bg_Touschek_LER_far: olivergreen\n"
174  "bg_RBB_gamma: skyblue\n"
175  "bg_none: orange\n"
176  "bg_other: orange\n"
177  "bg_twoPhoton: violet\n"
178  );
179 }
180 
181 std::string MCSegmentIdColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
182 {
184  mcHitLookUp.getInstance();
185  TrackFindingCDC::Index inTrackiSegment = mcHitLookUp.getInTrackSegmentId(&hit);
186 
187  if (inTrackiSegment < 0) {
188  return (c_bkgHitColor);
189  } else {
190  // values are all fractions of their respective scale
191  double hue = 50 * inTrackiSegment % 360 / 360.0;
192  double saturation = 0.75, lightness = 0.5;
193  std::array<double, 3> rgb = Colors::hlsToRgb(hue, lightness, saturation);
194  std::ostringstream oss;
195  std::string color;
196  oss << "rgb(" << rgb[0] * 100 << "%, " << rgb[1] * 100 << "%, " << rgb[2] * 100 << "%)";
197  color = oss.str();
198  return color;
199  }
200 }
201 
202 std::string TOFColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
203 {
204  CDCSimHit* simHit = hit.getRelated<CDCSimHit>("CDCSimHits");
205  double timeOfFlight = simHit->getFlightTime();
206  return timeOfFlightToColor(timeOfFlight);
207 }
208 
209 std::string TOFColorMap::timeOfFlightToColor(const double timeOfFlight)
210 {
211  //values are all fractions of their respective scale
212 
213  //Full color circle in 3 nanoseconds
214  double hue = fmod(360 / 3.0 * timeOfFlight, 360) / 360;
215  double saturation = 0.75, lightness = 0.5;
216  std::array<double, 3> rgb = Colors::hlsToRgb(hue, lightness, saturation);
217  std::ostringstream oss;
218  std::string color;
219  oss << "rgb(" << rgb[0] * 100 << "%, " << rgb[1] * 100 << "%, " << rgb[2] * 100 << "%)";
220  color = oss.str();
221  return color;
222 }
223 
224 std::string ReassignedSecondaryMap::map(int index __attribute__((unused)), const CDCHit& hit)
225 {
226  RelationVector<MCParticle> relatedMCParticles =
227  hit.getRelationsWith<MCParticle>("MCParticles");
228  if (relatedMCParticles.size() == 0) {
229  return c_bkgHitColor;
230  } else {
231  double mcRelationWeight = relatedMCParticles.weight(0);
232  if (mcRelationWeight > 0) {
233  return "green";
234  } else {
235  return "red";
236  }
237  }
238 }
239 
241  : m_colors(Colors::getList())
242  , m_iColor(0)
243  , m_usedColors()
244 {
245 }
246 
248 {
249  std::ostringstream oss;
250  for (const std::pair<int, std::string>& colorForMCParticleID : m_usedColors) {
251  oss << "MCParticle " << colorForMCParticleID.first << " -> " << colorForMCParticleID.second << "\n";
252  }
253  return oss.str();
254 }
255 
256 std::string MCParticleColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
257 {
258  MCParticle* mcParticle = hit.getRelated<MCParticle>("MCParticles");
259  if (mcParticle != nullptr) {
260  int mcParticleId = mcParticle->getArrayIndex();
261  if (m_usedColors.count(mcParticleId) == 1) {
262  return m_usedColors[mcParticleId];
263  } else {
264  ++m_iColor;
265  std::string color = m_colors[m_iColor % m_colors.size()];
266  m_usedColors.emplace(mcParticleId, color);
267  return color;
268  }
269  } else {
270  return c_bkgHitColor;
271  }
272 }
273 
274 std::string MCPDGCodeColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
275 {
276  MCParticle* mcParticle = hit.getRelated<MCParticle>("MCParticles");
277  int pdgCode = mcParticle != nullptr ? mcParticle->getPDG() : -999;
278 
279  auto itFound = c_colorByPDGCode.find(pdgCode);
280  if (itFound != c_colorByPDGCode.end()) {
281  return itFound->second;
282  } else {
283  B2WARNING("Unknown PDG code " << pdgCode);
284  return c_missingPDGColor;
285  }
286 }
287 
289 {
290  std::ostringstream oss;
291  oss << "\nLegend:";
292 
293  std::map<std::string, std::set<int>> pdgCodeByColor;
294 
295  for (auto item : c_colorByPDGCode) {
296  pdgCodeByColor[item.second].insert(item.first);
297  }
298 
299  for (auto item : pdgCodeByColor) {
300  oss << '\n' << item.first << "->[";
301  oss << join(", ", item.second);
302  oss << ']';
303  }
304  oss << '\n';
305  return oss.str();
306 }
307 
308 std::string MCPrimaryColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
309 {
310  MCParticle* mcParticle = hit.getRelated<MCParticle>("MCParticles");
311  if (mcParticle != nullptr) {
312  unsigned short int primaryFlag = 1;
313  bool isPrimary = mcParticle->hasStatus(primaryFlag);
314  int secondaryProcess = mcParticle->getSecondaryPhysicsProcess();
315 
316  if (isPrimary) {
317  return "blue";
318  } else if (secondaryProcess > 200) {
319  return "green"; // decay in flight
320  } else {
321  return "red";
322  }
323  } else {
324  return c_bkgHitColor;
325  }
326 }
327 
329 {
330  return "Legend:\n"
331  "blue->primary\n"
332  "green->secondary decay in flight\n"
333  "orange->beam background\n";
334 }
335 
336 std::string SimHitPDGCodeColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
337 {
338  CDCSimHit* simHit = hit.getRelated<CDCSimHit>("CDCSimHits");
339  int pdgCode = simHit != nullptr ? simHit->getPDGCode() : -999;
340  auto itFound = c_colorByPDGCode.find(pdgCode);
341  if (itFound != c_colorByPDGCode.end()) {
342  return itFound->second;
343  } else {
344  B2WARNING("Unknown PDG code " << pdgCode);
345  return c_missingPDGColor;
346  }
347 }
348 
350 {
351  std::ostringstream oss;
352  oss << "\nLegend:";
353 
354  std::map<std::string, std::set<int>> pdgCodeByColor;
355 
356  for (auto item : c_colorByPDGCode) {
357  pdgCodeByColor[item.second].insert(item.first);
358  }
359 
360  for (auto item : pdgCodeByColor) {
361  oss << '\n' << item.first << "->[";
362  oss << join(", ", item.second);
363  oss << ']';
364  }
365  oss << '\n';
366  return oss.str();
367 }
368 
369 std::string SimHitIsBkgColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
370 {
371  CDCSimHit* simHit = hit.getRelated<CDCSimHit>("CDCSimHits");
372  bool bkgTag = simHit->getBackgroundTag();
373  if (bkgTag) {
374  return "gray";
375  } else {
376  return "red";
377  }
378 }
379 
380 std::string NLoopsColorMap::map(int index __attribute__((unused)), const CDCHit& hit)
381 {
382  const CDCMCHitLookUp& mcHitLookUp = mcHitLookUp.getInstance();
383 
384  int nLoops = mcHitLookUp.getNLoops(&hit);
385 
386  if (nLoops < 0) {
387  return c_bkgHitColor;
388  }
389  return Colors::getWheelColor(70 * nLoops);
390 }
Belle2::RelationVector::size
size_t size() const
Get number of relations.
Definition: RelationVector.h:98
Belle2::CDCSimHit::getFlightTime
double getFlightTime() const
The method to get flight time.
Definition: CDCSimHit.h:201
Belle2::TrackFindingCDC::CDCWireHit::getAutomatonCell
AutomatonCell & getAutomatonCell() const
Mutable getter for the automaton cell.
Definition: CDCWireHit.h:294
Belle2::TrackFindingCDC::MCParticleColorMap::MCParticleColorMap
MCParticleColorMap()
Constructor setting up a Monte Carlo id to color map which is continously filled as new during the ev...
Definition: HitColorMapping.cc:240
Belle2::CDCSimHit::getPosFlag
int getPosFlag() const
The method to get old left/right info.
Definition: CDCSimHit.h:240
Belle2::TrackFindingCDC::CDCWireHit::getRefDriftLength
double getRefDriftLength() const
Getter for the drift length at the reference position of the wire.
Definition: CDCWireHit.h:232
Belle2::CDCHit
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition: CDCHit.h:51
Belle2::TrackFindingCDC::PosFlagColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:112
Belle2::TrackFindingCDC::TakenFlagColorMap::TakenFlagColorMap
TakenFlagColorMap()
Constructor checking if the CDCWireHits caring the taken flag are accessable.
Definition: HitColorMapping.cc:71
Belle2::TrackFindingCDC::MCPDGCodeColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:274
Belle2::TrackFindingCDC::SimHitIsBkgColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:369
Belle2::TrackFindingCDC::ZeroDriftLengthColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:51
Belle2::TrackFindingCDC::MCParticleColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:256
Belle2::TrackFindingCDC::NLoopsColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map a segments object from the local finder to a color.
Definition: HitColorMapping.cc:380
Belle2::CDCSimHit
Example Detector.
Definition: CDCSimHit.h:33
Belle2::MCParticle::getArrayIndex
int getArrayIndex() const
Get 0-based index of the particle in the corresponding MCParticle list.
Definition: MCParticle.h:255
Belle2::MCParticle::getSecondaryPhysicsProcess
int getSecondaryPhysicsProcess() const
Returns the physics process type of a secondary particle.
Definition: MCParticle.h:305
Belle2::TrackFindingCDC::PosFlagColorMap::info
std::string info() override
Informal string summarizing the translation from CDCSimHit::getPosFlag variable to colors.
Definition: HitColorMapping.cc:125
Belle2::TrackFindingCDC::MCParticleColorMap::m_colors
std::vector< std::string > m_colors
List of colors to be cycled.
Definition: HitColorMapping.h:137
Belle2::TrackFindingCDC::SimHitPDGCodeColorMap::info
std::string info() override
Informal string summarizing the translation from pdg codes to colors.
Definition: HitColorMapping.cc:349
Belle2::TrackFindingCDC::RLColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:94
Belle2::TrackFindingCDC::MCParticleColorMap::m_iColor
int m_iColor
Index of the color to be used next.
Definition: HitColorMapping.h:140
Belle2::MCParticle::hasStatus
bool hasStatus(unsigned short int bitmask) const
Return if specific status bit is set.
Definition: MCParticle.h:140
Belle2::TrackFindingCDC::RLColorMap::info
std::string info() override
Informal string summarizing the translation from right left passage variable to colors.
Definition: HitColorMapping.cc:107
Belle2::TrackFindingCDC::MCSegmentIdColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:181
Belle2::RelationVector
Class for type safe access to objects that are referred to in relations.
Definition: DataStore.h:38
Belle2::TrackFindingCDC::BackgroundTagColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:130
Belle2::TrackFindingCDC::MCParticleColorMap::info
std::string info() override
Informal string summarizing the translation from CDCSimHit::getBackgroundTag.
Definition: HitColorMapping.cc:247
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::CDCMCHitLookUp
Interface class to the Monte Carlo information for individual hits.
Definition: CDCMCHitLookUp.h:41
Belle2::TrackFindingCDC::Colors::hlsToRgb
static std::array< double, 3 > hlsToRgb(double h, double l, double s)
Transforms a Color given in the HLS System to RGB.
Definition: Colors.cc:58
Belle2::TrackFindingCDC::CDCMCHitLookUp::getNLoops
Index getNLoops(const CDCHit *ptrHit) const
Returns the number of loops the track traversed until this hit.
Definition: CDCMCHitLookUp.cc:147
Belle2::TrackFindingCDC::MCParticleColorMap::m_usedColors
std::map< int, std::string > m_usedColors
Mapping of the already used colors by the MCParticle::getArrayId to map later CDCHits to the same col...
Definition: HitColorMapping.h:146
Belle2::MCParticle::getPDG
int getPDG() const
Return PDG code of particle.
Definition: MCParticle.h:123
Belle2::TrackFindingCDC::SimHitPDGCodeColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:336
Belle2::TrackFindingCDC::Range
A pair of iterators usable with the range base for loop.
Definition: Range.h:35
Belle2::TrackFindingCDC::BackgroundTagColorMap::info
std::string info() override
Informal string summarizing the translation from CDCSimHit::getBackgroundTag.
Definition: HitColorMapping.cc:159
Belle2::TrackFindingCDC::AutomatonCell::hasTakenFlag
bool hasTakenFlag() const
Gets the current state of the taken marker flag.
Definition: AutomatonCell.h:249
Belle2::TrackFindingCDC::CDCMCHitLookUp::getInstance
static const CDCMCHitLookUp & getInstance()
Getter for the singletone instance.
Definition: CDCMCHitLookUp.cc:32
Belle2::TrackFindingCDC::TakenFlagColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:78
Belle2::RelationVector::weight
float weight(int index) const
Get weight with index.
Definition: RelationVector.h:120
Belle2::TrackFindingCDC::TOFColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:202
Belle2::SimHitBase::getBackgroundTag
virtual unsigned short getBackgroundTag() const
Get background tag.
Definition: SimHitBase.h:56
Belle2::TrackFindingCDC::TOFColorMap::timeOfFlightToColor
std::string timeOfFlightToColor(const double timeOfFlight)
Translates the given floating point time of flight to a color.
Definition: HitColorMapping.cc:209
Belle2::TrackFindingCDC::CDCMCHitLookUp::getRLInfo
ERightLeft getRLInfo(const CDCHit *ptrHit) const
Returns the true right left passage information.
Definition: CDCMCHitLookUp.cc:109
Belle2::TrackFindingCDC::Colors::getWheelColor
static std::string getWheelColor(int degree)
Get a color from the wheel of colors.
Definition: Colors.cc:73
Belle2::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:43
Belle2::TrackFindingCDC::CDCWireHit
Class representing a hit wire in the central drift chamber.
Definition: CDCWireHit.h:65
Belle2::TrackFindingCDC::MCPrimaryColorMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:308
Belle2::TrackFindingCDC::ReassignedSecondaryMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a color.
Definition: HitColorMapping.cc:224
Belle2::TrackFindingCDC::TakenFlagColorMap::m_storedWireHits
StoreWrappedObjPtr< std::vector< CDCWireHit > > m_storedWireHits
Memory of the handle to the CDCWireHits on the DataStore.
Definition: HitColorMapping.h:67
Belle2::TrackFindingCDC::Colors
Utility functions related to colors.
Definition: Colors.h:32
Belle2::CDCSimHit::getPDGCode
int getPDGCode() const
The method to get PDG code.
Definition: CDCSimHit.h:195
Belle2::TrackFindingCDC::MCPrimaryColorMap::info
std::string info() override
Informal string summarizing the translation from seconday process codes to colors.
Definition: HitColorMapping.cc:328
Belle2::TrackFindingCDC::MCPDGCodeColorMap::info
std::string info() override
Informal string summarizing the translation from pdg codes to colors.
Definition: HitColorMapping.cc:288
Belle2::TrackFindingCDC::CDCMCHitLookUp::getInTrackSegmentId
Index getInTrackSegmentId(const CDCHit *ptrHit) const
Returns the id of the segment in the track.
Definition: CDCMCHitLookUp.cc:135
Belle2::TrackFindingCDC::ZeroDriftLengthStrokeWidthMap::map
std::string map(int index, const CDCHit &hit) override
Function call to map the CDCHit id and object to a stroke width.
Definition: HitColorMapping.cc:61