CDCSVGPlotter Class Reference

Helper class to generated the svg image from the various tracking objects. More...

#include <CDCSVGPlotter.h>

Collaboration diagram for CDCSVGPlotter:

Public Member Functions
	CDCSVGPlotter (bool animate=false, bool forwardFade=false)
	Constructor.
CDCSVGPlotter *	clone ()
	Make a copy of the current status of the plotter.
void	drawWires (const CDCWireTopology &cdcWireTopology)
	Draws the wires.
void	drawInteractionPoint ()
	Draws the interaction point.
void	drawSuperLayerBoundaries (const std::string &stroke)
	Draws the individual super layer boundaries.
void	drawOuterCDCWall (const std::string &stroke)
	Draws the outer CDCWall.
void	drawInnerCDCWall (const std::string &stroke)
	Draws the inner CDCWall.
void	drawHits (const std::string &storeArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draws CDCHits.
void	drawSimHits (const std::string &storeArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draws CDCSimHits.
void	drawClusters (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws CDCWireHitClusters.
void	drawSegments (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws CDCSegments.
void	drawSegmentTrajectories (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws SegmentTrajectories.
void	drawSegmentPairs (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draw the axial to stereo segment pairs.
void	drawAxialSegmentPairs (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draw the axial to axial segment pairs.
void	drawSegmentTriples (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draw the axial, stereo, axial segment triples.
void	drawSegmentTripleTrajectories (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draw the trajectories of the axial, stereo, axial segment triples.
void	drawTracks (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws CDCTracks.
void	drawTrackTrajectories (const std::string &storeObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws trajectories of the tracks.
void	drawRecoTracks (const std::string &storeArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draw RecoTracks.
void	drawRecoTrackTrajectories (const std::string &storeArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draw RecoTracks trajectories.
void	drawMCParticleTrajectories (const std::string &storeArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draw MCParticles.
void	drawWrongRLHitsInSegments (const std::string &segmentsStoreObjName)
	Draw the CDCRLWireHits in the CDCSegments colored by the match of the right left passage informations.
void	drawWrongRLHitsInTracks (const std::string &tracksStoreObjName)
	Draw the CDCRLWireHits in the CDCTracks colored by the match of the right left passage informations.
void	drawSimHitsConnectByToF (const std::string &simHitStoreArrayName, const std::string &stroke, const std::string &strokeWidth)
	Draw the CDCSimHits connected in the order of their getFlightTime for each Monte Carlo particle.
void	drawMCSegmentPairs (const std::string &segmentsStoreObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws the Monte Carlo true CDCSegmentPairs.
void	drawMCAxialSegmentPairs (const std::string &segmentsStoreObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws the Monte Carlo true CDCAxialSegmentPairs.
void	drawMCSegmentTriples (const std::string &segmentsStoreObjName, const std::string &stroke, const std::string &strokeWidth)
	Draws the Monte Carlo true CDCSegmentTriples.
std::string	saveFile (const std::string &fileName="display.svg")
	Save the current dom object representation to disk.

Private Member Functions
template<class ACDCHitCollection >
void	drawWrongRLHits (const std::string &storeObjName)
	Draw the CDCRLWireHits in the ACDCHitCollection colored by the match of the right left passage informations.
template<class AItem , bool a_drawTrajectories = false>
void	drawStoreArray (const std::string &storeArrayName, Styling< AItem > &styling)
	Function Template for drawing the elements of a given StoreArray.
template<class AItem , bool a_drawTrajectories = false>
void	drawStoreVector (const std::string &storeObjName, Styling< AItem > &styling)
	Function Template for drawing the elements of a given StoreVector.
template<bool a_drawTrajectory = false, class AIterable , class AStyling >
void	drawIterable (const AIterable &items, AStyling &styling)
	Draw every element of an iterable object.
template<bool a_drawTrajectory = false, class AObject >
void	draw (const AObject &object, const AttributeMap &attributeMap)
	Draws the object or its trajectory with the given attributes.

Private Attributes
EventDataPlotter	m_eventdataPlotter
	The plotter instance to translate event data objects to svg expressions.

Detailed Description

Helper class to generated the svg image from the various tracking objects.

Definition at line 23 of file CDCSVGPlotter.h.

Constructor & Destructor Documentation

CDCSVGPlotter()

CDCSVGPlotter	(	bool	animate = false,
		bool	forwardFade = false
	)

Constructor.

Definition at line 102 of file CDCSVGPlotter.cc.

                                                           :
  m_eventdataPlotter(std::make_unique<SVGPrimitivePlotter>(c_defaultSVGAttributes), animate, forwardFade)
{
  int top = -112;
  int left = -112;
  int right = 112;
  int bottom = 112;
 
  TrackFindingCDC::BoundingBox default_bound(left, bottom, right, top);
  int default_width = 1120;
  int default_height = 1120;
 
  m_eventdataPlotter.setBoundingBox(default_bound);
  m_eventdataPlotter.setCanvasHeight(default_height);
  m_eventdataPlotter.setCanvasWidth(default_width);
}

Member Function Documentation

clone()

CDCSVGPlotter * clone

(

)

Make a copy of the current status of the plotter.

Definition at line 119 of file CDCSVGPlotter.cc.

{
  return (new CDCSVGPlotter(*this));
}

drawAxialSegmentPairs()

void drawAxialSegmentPairs	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw the axial to axial segment pairs.

Parameters

storeObjName	The name of the StoreVector containing the CDCAxialSegmentPairs.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCAxialSegmentPair and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCAxialSegmentPair and its id to a stroke-width.

Definition at line 222 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCAxialSegmentPair> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCAxialSegmentPair>(storeObjName, styling);
}

drawClusters()

void drawClusters	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws CDCWireHitClusters.

Parameters

storeObjName	The name of the StoreVector containing the CDCWireHitClusters.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 191 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCWireHitCluster> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCWireHitCluster>(storeObjName, styling);
}

drawHits()

void drawHits	(	const std::string &	storeArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws CDCHits.

Parameters

storeArrayName	The name of the StoreArray containing the CDCHits.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 155 of file CDCSVGPlotter.cc.

{
  ChooseableHitStyling styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreArray<const CDCHit>(storeArrayName, styling);
}

drawInnerCDCWall()

void drawInnerCDCWall

(

const std::string &

stroke

)

Draws the inner CDCWall.

Parameters

stroke

The color to be used for drawing.

Definition at line 143 of file CDCSVGPlotter.cc.

{
  AttributeMap attributeMap;
  attributeMap.emplace("stroke", stroke);
  m_eventdataPlotter.drawInnerCDCWall(attributeMap);
}

drawInteractionPoint()

void drawInteractionPoint

(

)

Draws the interaction point.

Definition at line 124 of file CDCSVGPlotter.cc.

{
  m_eventdataPlotter.drawInteractionPoint();
}

drawIterable()

void drawIterable ( const AIterable &  items, AStyling &  styling  )

private

Draw every element of an iterable object.

Template Parameters

a_drawTrajectory

Switch to draw the fitted trajectory from the object instead.

Parameters

items	An iterable object (StoreArray, std::vector...).
styling	Styling object from which drawing attributes are constructed

drawMCAxialSegmentPairs()

void drawMCAxialSegmentPairs	(	const std::string &	segmentsStoreObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws the Monte Carlo true CDCAxialSegmentPairs.

This routine creates the true axial segment pairs from the stored segments to get an overview which cases the segment triple reconstruction should cover.

Parameters

segmentsStoreObjName	The name of the StoreVector containing the CDCSegment2Ds, from which the pair should be constructed.
stroke	Color of the lines to be drawn.
strokeWidth	Width of the lines to be drawn.

Definition at line 471 of file CDCSVGPlotter.cc.

{
  B2INFO("Draw axial to axial segment pairs");
  StoreWrappedObjPtr<std::vector<CDCSegment2D>> storedSegments(segmentsStoreObjName);
  if (not storedSegments) {
    B2WARNING(segmentsStoreObjName << "does not exist in current DataStore");
    printDataStoreContent();
    return;
  }
 
  std::vector<CDCSegment2D>& segments = *storedSegments;
  B2INFO("#Segments: " << segments.size());
 
  std::vector<const CDCAxialSegment2D*> axialSegments;
  for (const CDCAxialSegment2D& segment : segments) {
    if (segment.isAxial()) axialSegments.push_back(&segment);
  }
 
  MCAxialSegmentPairFilter mcAxialSegmentPairFilter;
  std::vector<CDCAxialSegmentPair> mcAxialSegmentPairs;
  for (const CDCAxialSegment2D* fromSegment : axialSegments) {
    for (const CDCAxialSegment2D* toSegment : axialSegments) {
      if (fromSegment == toSegment) continue;
      mcAxialSegmentPairs.emplace_back(fromSegment, toSegment);
      Weight mcWeight = mcAxialSegmentPairFilter(mcAxialSegmentPairs.back());
      // Remove segment pairs that are not true
      if (std::isnan(mcWeight)) {
        mcAxialSegmentPairs.pop_back();
      }
    }
  }
  B2INFO("# Axial segment pairs: " << mcAxialSegmentPairs.size());
  FixedStyling<const CDCAxialSegmentPair> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStroke(strokeWidth);
  drawIterable(mcAxialSegmentPairs, styling);
}

drawMCParticleTrajectories()

void drawMCParticleTrajectories	(	const std::string &	storeArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw MCParticles.

Parameters

storeArrayName	The name of the StoreArray containing the RecoTracks.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 305 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const MCParticle> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  const bool drawTrajectories = true;
  drawStoreArray<const MCParticle, drawTrajectories>(storeArrayName, styling);
}

drawMCSegmentPairs()

void drawMCSegmentPairs	(	const std::string &	segmentsStoreObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws the Monte Carlo true CDCSegmentPairs.

This routine creates the true segment pairs from the stored segments to get an overview which cases the segment triple reconstruction should cover.

Parameters

segmentsStoreObjName	The name of the StoreVector containing the CDCSegment2Ds, from which the pair should be constructed.
stroke	Color of the lines to be drawn.
strokeWidth	Width of the lines to be drawn.

Definition at line 511 of file CDCSVGPlotter.cc.

{
  B2INFO("Draw axial to stero segment pairs");
  StoreWrappedObjPtr<std::vector<CDCSegment2D>> storedSegments(segmentsStoreObjName);
  if (not storedSegments) {
    B2WARNING(segmentsStoreObjName << "does not exist in current DataStore");
    printDataStoreContent();
    return;
  }
 
  std::vector<CDCSegment2D>& segments = *storedSegments;
  B2INFO("#Segments: " << segments.size());
 
  std::vector<const CDCAxialSegment2D*> axialSegments;
  std::vector<const CDCStereoSegment2D*> stereoSegments;
  for (const CDCAxialSegment2D& segment : segments) {
    if (segment.isAxial()) {
      axialSegments.push_back(&segment);
    } else {
      stereoSegments.push_back(&segment);
    }
  }
 
  MCSegmentPairFilter mcSegmentPairFilter;
  std::vector<CDCSegmentPair> mcSegmentPairs;
  for (const CDCAxialSegment2D* axialSegment : axialSegments) {
    for (const CDCStereoSegment2D* stereoSegment : stereoSegments) {
      // Axial first
      {
        mcSegmentPairs.emplace_back(axialSegment, stereoSegment);
        Weight mcWeight = mcSegmentPairFilter(mcSegmentPairs.back());
        // Remove segment pairs that are not true
        if (std::isnan(mcWeight)) {
          mcSegmentPairs.pop_back();
        }
      }
      // Stereo first
      {
        mcSegmentPairs.emplace_back(stereoSegment, axialSegment);
        Weight mcWeight = mcSegmentPairFilter(mcSegmentPairs.back());
        // Remove segment pairs that are not true
        if (std::isnan(mcWeight)) {
          mcSegmentPairs.pop_back();
        }
      }
    }
  }
  B2INFO("# Segment pairs: " << mcSegmentPairs.size());
  FixedStyling<const CDCSegmentPair> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStroke(strokeWidth);
  drawIterable(mcSegmentPairs, styling);
}

drawMCSegmentTriples()

void drawMCSegmentTriples	(	const std::string &	segmentsStoreObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws the Monte Carlo true CDCSegmentTriples.

This routine creates the true segment triples from the stored segments to get an overview which cases the segment triple reconstruction should cover.

Parameters

segmentsStoreObjName	The name of the StoreVector containing the CDCSegment2Ds, from which the pair should be constructed.
stroke	Color of the lines to be drawn.
strokeWidth	Width of the lines to be drawn.

Definition at line 567 of file CDCSVGPlotter.cc.

{
  B2INFO("Draw segment triples");
  StoreWrappedObjPtr<std::vector<CDCSegment2D>> storedSegments(segmentsStoreObjName);
  if (not storedSegments) {
    B2WARNING(segmentsStoreObjName << "does not exist in current DataStore");
    printDataStoreContent();
    return;
  }
 
  std::vector<CDCSegment2D>& segments = *storedSegments;
  B2INFO("#Segment " << segments.size());
 
  std::vector<const CDCAxialSegment2D*> axialSegments;
  std::vector<const CDCStereoSegment2D*> stereoSegments;
  for (const CDCSegment2D& segment : segments) {
    if (segment.isAxial()) {
      axialSegments.push_back(&segment);
    } else {
      stereoSegments.push_back(&segment);
    }
  }
 
  MCSegmentTripleFilter mcSegmentTripleFilter;
  std::vector<CDCSegmentTriple> mcSegmentTriples;
  for (const CDCAxialSegment2D* startSegment : axialSegments) {
    for (const CDCStereoSegment2D* middleSegment : stereoSegments) {
      for (const CDCAxialSegment2D* endSegment : axialSegments) {
        if (startSegment == endSegment) continue;
        mcSegmentTriples.emplace_back(startSegment, middleSegment, endSegment);
        Weight mcWeight = mcSegmentTripleFilter(mcSegmentTriples.back());
        // Remove segment pairs that are not true
        if (std::isnan(mcWeight)) {
          mcSegmentTriples.pop_back();
        }
      }
    }
  }
  B2INFO("# Segment triples: " << mcSegmentTriples.size());
  FixedStyling<const CDCSegmentTriple> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStroke(strokeWidth);
  drawIterable(mcSegmentTriples, styling);
}

drawOuterCDCWall()

void drawOuterCDCWall

(

const std::string &

stroke

)

Draws the outer CDCWall.

Parameters

stroke

The color to be used for drawing.

Definition at line 136 of file CDCSVGPlotter.cc.

{
  AttributeMap attributeMap;
  attributeMap.emplace("stroke", stroke);
  m_eventdataPlotter.drawOuterCDCWall(attributeMap);
}

drawRecoTracks()

void drawRecoTracks	(	const std::string &	storeArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw RecoTracks.

Parameters

storeArrayName	The name of the StoreArray containing the RecoTracks.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 284 of file CDCSVGPlotter.cc.

{
  ChooseableRecoTrackStyling styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreArray<const RecoTrack>(storeArrayName, styling);
}

drawRecoTrackTrajectories()

void drawRecoTrackTrajectories	(	const std::string &	storeArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw RecoTracks trajectories.

Parameters

storeArrayName	The name of the StoreArray containing the RecoTracks.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 294 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const RecoTrack> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  const bool drawTrajectories = true;
  drawStoreArray<const RecoTrack, drawTrajectories>(storeArrayName, styling);
}

drawSegmentPairs()

void drawSegmentPairs	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw the axial to stereo segment pairs.

Parameters

storeObjName	The name of the StoreVector containing the CDCSegmentPairs.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCSegmentPair and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCSegmentPair and its id to a stroke-width.

Definition at line 232 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCSegmentPair> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCSegmentPair>(storeObjName, styling);
}

drawSegments()

void drawSegments	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws CDCSegments.

Parameters

storeObjName	The name of the StoreVector containing the CDCSegments.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 201 of file CDCSVGPlotter.cc.

{
  ChooseableSegmentStyling styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCSegment2D>(storeObjName, styling);
}

drawSegmentTrajectories()

void drawSegmentTrajectories	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws SegmentTrajectories.

Parameters

storeObjName	The name of the StoreVector containing the CDCSegments.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 211 of file CDCSVGPlotter.cc.

{
  FixedStyling<const CDCSegment2D> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  const bool drawTrajectories = true;
  drawStoreVector<const CDCSegment2D, drawTrajectories>(storeObjName, styling);
}

drawSegmentTriples()

void drawSegmentTriples	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw the axial, stereo, axial segment triples.

Parameters

storeObjName	The name of the StoreVector containing the CDCSegmentTriples.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a stroke-width.

Definition at line 242 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCSegmentTriple> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCSegmentTriple>(storeObjName, styling);
}

drawSegmentTripleTrajectories()

void drawSegmentTripleTrajectories	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw the trajectories of the axial, stereo, axial segment triples.

Parameters

storeObjName	The name of the StoreVector containing the CDCSegmentTriples.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a stroke-width.

Definition at line 252 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCSegmentTriple> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  const bool drawTrajectories = true;
  drawStoreVector<const CDCSegmentTriple, drawTrajectories>(storeObjName, styling);
}

drawSimHits()

void drawSimHits	(	const std::string &	storeArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws CDCSimHits.

Parameters

storeArrayName	The name of the StoreArray containing the CDCSimHits.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCSimHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCSimHit and its id to a stroke-width.

Definition at line 165 of file CDCSVGPlotter.cc.

{
  B2INFO("Drawing simulated hits");
  StoreArray<CDCHit> storeArray(storeArrayName);
  if (not storeArray) {
    B2WARNING("StoreArray " << storeArrayName << " not present");
    printDataStoreContent();
    return;
  }
  std::vector<CDCSimHit> simHitsRelatedToHits;
  for (const CDCHit& hit : storeArray) {
    simHitsRelatedToHits.push_back(*hit.getRelated<CDCSimHit>("CDCSimHits"));
  }
  B2INFO("#CDCSimHits: " << storeArray.getEntries());
  FixedStyling<const CDCSimHit> styling;
  if (stroke != "") {
    styling.setStroke("orange");
  } else {
    styling.setStroke(stroke);
  }
  styling.setStrokeWidth(strokeWidth);
  drawIterable(simHitsRelatedToHits, styling);
}

drawSimHitsConnectByToF()

void drawSimHitsConnectByToF	(	const std::string &	simHitStoreArrayName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draw the CDCSimHits connected in the order of their getFlightTime for each Monte Carlo particle.

Parameters

simHitStoreArrayName	The name of the StoreArray containing the CDCSimHits.
stroke	Color of the lines to be drawn.
strokeWidth	Width of the lines to be drawn.

Definition at line 316 of file CDCSVGPlotter.cc.

{
  B2INFO("Drawing simulated hits connected by tof");
  StoreArray<CDCHit> hitStoreArray(hitStoreArrayName);
  if (not hitStoreArray) {
    B2WARNING("StoreArray " << hitStoreArrayName << " not present");
    printDataStoreContent();
    return;
  }
  std::vector<CDCSimHit*> simHits;
  for (const CDCHit& hit : hitStoreArray) {
    simHits.push_back(hit.getRelated<CDCSimHit>());
  }
 
  // group them by their mcparticle id
  std::map<int, std::set<CDCSimHit*, FlightTimeOrder>> simHitsByMcParticleId;
  for (CDCSimHit* simHit : simHits) {
    MCParticle* mcParticle = simHit->getRelated<MCParticle>();
    if (mcParticle != nullptr) {
      int mcTrackId = mcParticle->getArrayIndex();
      simHitsByMcParticleId[mcTrackId].insert(simHit);
    }
  }
 
  AttributeMap defaultAttributeMap = {{"stroke", stroke}, {"stroke-width", strokeWidth}};
 
  for (const auto& mcParticleIdAndSimHits : simHitsByMcParticleId) {
    const std::set<CDCSimHit*, FlightTimeOrder>& simHitsForMcParticle =
      mcParticleIdAndSimHits.second;
 
    auto drawConnectSimHits = [this, &defaultAttributeMap](CDCSimHit * fromSimHit, CDCSimHit * toSimHit) {
 
      CDCHit* fromHit = fromSimHit->getRelated<CDCHit>();
      CDCHit* toHit = toSimHit->getRelated<CDCHit>();
      if (fromHit == nullptr) return false;
      if (toHit == nullptr) return false;
 
      CDCWireHit fromWireHit(fromHit);
      CDCWireHit toWireHit(toHit);
 
      CDCRLWireHit fromRLWireHit(&fromWireHit);
      CDCRLWireHit toRLWireHit(&toWireHit);
 
      Vector3D fromDisplacement(fromSimHit->getPosTrack() - fromSimHit->getPosWire());
      Vector3D toDisplacement(toSimHit->getPosTrack() - toSimHit->getPosWire());
 
      CDCRecoHit2D fromRecoHit2D(fromRLWireHit, fromDisplacement.xy());
      CDCRecoHit2D toRecoHit2D(toRLWireHit, toDisplacement.xy());
 
      bool falseOrder = false;
      if (fromSimHit->getArrayIndex() > toSimHit->getArrayIndex()) {
        bool fromReassigned = fromHit->getRelatedWithWeight<MCParticle>().second < 0;
        bool toReassigned = toHit->getRelatedWithWeight<MCParticle>().second < 0;
        if (not fromReassigned and not toReassigned) {
          falseOrder = true;
        }
      }
 
      AttributeMap attributeMap = defaultAttributeMap;
      if (falseOrder) {
        attributeMap["stroke"] = "red";
        attributeMap["stroke-width"] = "1.0";
      }
      draw(fromRecoHit2D, attributeMap);
      draw(toRecoHit2D, attributeMap);
 
      const Vector2D fromPos = fromRecoHit2D.getRecoPos2D();
      const float fromX = fromPos.x();
      const float fromY = fromPos.y();
 
      const Vector2D toPos = toRecoHit2D.getRecoPos2D();
      const float toX = toPos.x();
      const float toY = toPos.y();
 
      m_eventdataPlotter.drawLine(fromX, fromY, toX, toY, attributeMap);
      return false;
    };
 
    // cppcheck-suppress ignoredReturnValue
    std::adjacent_find(simHitsForMcParticle.begin(),
                       simHitsForMcParticle.end(),
                       drawConnectSimHits);
  }
}

drawStoreArray()

void drawStoreArray ( const std::string &  storeArrayName, Styling< AItem > &  styling  )

private

Function Template for drawing the elements of a given StoreArray.

Needs to know the type of the objects in the StoreArray and the right styling for these objects.

Template Parameters

a_drawTrajectories

Switch to draw the fitted trajectory from the object instead.

Parameters

storeArrayName	The name of the StoreArray containing the objects.
styling	Functional object to construct attributes for each object to be drawn

drawStoreVector()

void drawStoreVector ( const std::string &  storeObjName, Styling< AItem > &  styling  )

private

Function Template for drawing the elements of a given StoreVector.

Needs to know the type of the objects in the store objects and the right styling for these objects.

Template Parameters

a_drawTrajectories

Switch to draw the fitted trajectory from the object instead.

Parameters

storeObjName	name of the StoreObject containing the objects.
styling	Functional object to construct attributes for each object to be drawn

drawSuperLayerBoundaries()

void drawSuperLayerBoundaries

(

const std::string &

stroke

)

Draws the individual super layer boundaries.

Parameters

stroke

The color to be used for drawing.

Definition at line 129 of file CDCSVGPlotter.cc.

{
  AttributeMap attributeMap;
  attributeMap.emplace("stroke", stroke);
  m_eventdataPlotter.drawSuperLayerBoundaries(attributeMap);
}

drawTracks()

void drawTracks	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws CDCTracks.

Parameters

storeObjName	The name of the StoreVector containing the CDCTracks.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCSegmentTriple and its id to a stroke-width.

Definition at line 263 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCTrack> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  drawStoreVector<const CDCTrack>(storeObjName, styling);
}

drawTrackTrajectories()

void drawTrackTrajectories	(	const std::string &	storeObjName,
		const std::string &	stroke,
		const std::string &	strokeWidth
	)

Draws trajectories of the tracks.

Parameters

storeObjName	The name of the StoreVector containing the CDCTracks.
stroke	Either the color to be used for drawing or the name of the method, which maps the CDCHit and its id to a color.
strokeWidth	Either the stroke-width to be used for drawing or the name of the method, which maps the CDCHit and its id to a stroke-width.

Definition at line 273 of file CDCSVGPlotter.cc.

{
  DefaultColorCycleStyling<const CDCTrack> styling;
  if (stroke != "") styling.setStroke(stroke);
  if (strokeWidth != "") styling.setStrokeWidth(strokeWidth);
  const bool drawTrajectories = true;
  drawStoreVector<const CDCTrack, drawTrajectories>(storeObjName, styling);
}

drawWires()

void drawWires

(

const CDCWireTopology &

cdcWireTopology

)

Draws the wires.

Definition at line 150 of file CDCSVGPlotter.cc.

{
  m_eventdataPlotter.draw(cdcWireTopology);
}

drawWrongRLHits()

void drawWrongRLHits ( const std::string &  storeObjName )

private

Draw the CDCRLWireHits in the ACDCHitCollection colored by the match of the right left passage informations.

It respects hit collections reconstructed backwards to have the opposite rl informations.

drawWrongRLHitsInSegments()

void drawWrongRLHitsInSegments

(

const std::string &

segmentsStoreObjName

)

Draw the CDCRLWireHits in the CDCSegments colored by the match of the right left passage informations.

It respects segments reconstructed backwards to have the opposite rl informations

Definition at line 403 of file CDCSVGPlotter.cc.

{
  this->drawWrongRLHits<CDCSegment2D>(segmentsStoreObjName);
}

drawWrongRLHitsInTracks()

void drawWrongRLHitsInTracks

(

const std::string &

tracksStoreObjName

)

Draw the CDCRLWireHits in the CDCTracks colored by the match of the right left passage informations.

It respects tracks reconstructed backwards to have the opposite rl informations

Definition at line 408 of file CDCSVGPlotter.cc.

{
  this->drawWrongRLHits<CDCTrack>(tracksStoreObjName);
}

saveFile()

std::string saveFile

(

const std::string &

fileName = "display.svg"

)

Save the current dom object representation to disk.

Parameters

fileName

The Name of the saved file. Defaults to "display.svg".

Definition at line 614 of file CDCSVGPlotter.cc.

{
  TrackFindingCDC::BoundingBox boundingBox = m_eventdataPlotter.getBoundingBox();
 
  float height = boundingBox.getHeight();
  float width = boundingBox.getWidth();
 
  int totalPoints = 1120 * 1120;
  float svgHeight = roundf(sqrt(totalPoints * height / width));
  float svgWidth = roundf(sqrt(totalPoints * width / height));
 
  m_eventdataPlotter.setCanvasHeight(svgHeight);
  m_eventdataPlotter.setCanvasWidth(svgWidth);
 
  return (m_eventdataPlotter.save(fileName));
}

Member Data Documentation

m_eventdataPlotter

EventDataPlotter m_eventdataPlotter

private

The plotter instance to translate event data objects to svg expressions.

Definition at line 330 of file CDCSVGPlotter.h.

---

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

• tracking/trackFindingCDC/display/include/CDCSVGPlotter.h
• tracking/trackFindingCDC/display/src/CDCSVGPlotter.cc