EVEVisualization Class Reference

Produces visualisation for MCParticles, simhits, genfit::Tracks, geometry and other things. More...

#include <EVEVisualization.h>

Classes
struct	ElementGroup
	Group of TEveElements, remembers wether user wants it visible or not. More...
struct	MCTrack
	Hold MC tracks and associated visualisation objects. More...

Public Member Functions
	EVEVisualization ()
	Constructor.
	EVEVisualization (const EVEVisualization &)=delete
	disabled.
EVEVisualization &	operator= (const EVEVisualization &)=delete
	disabled assignment
	~EVEVisualization ()
	Destructor.
void	addTrack (const Belle2::Track *belle2Track)
	Add this genfit::Track to event data.
void	addTrackCandidate (const std::string &collectionName, const RecoTrack &recoTrack)
	Add a RecoTrack, to evaluate track finding.
void	addTrackCandidateImproved (const std::string &collectionName, const RecoTrack &recoTrack)
	Add a RecoTrack, but use stored genfit track representation to make visualisation objects.
void	addCDCTriggerTrack (const std::string &collectionName, const CDCTriggerTrack &track)
	Add a CDCTriggerTrack.
template<class T >
void	addSimHits (const StoreArray< T > &hits)
	Add all entries in the given 'hits' array (and the corresponding MCParticles) to the event scene.
void	addSimHit (const CDCSimHit *hit, const MCParticle *particle)
	Add a CDCSimHit.
void	addSimHit (const PXDSimHit *hit, const MCParticle *particle)
	Add a PXDSimHit.
void	addSimHit (const SVDSimHit *hit, const MCParticle *particle)
	Add a SVDSimHit.
void	addSimHit (const KLMSimHit *hit, const MCParticle *particle)
	Add a KLMSimHit.
void	addSimHit (const ROOT::Math::XYZVector &v, const MCParticle *particle)
	Add simhit as a simple point.
MCTrack *	addMCParticle (const MCParticle *particle)
	Return MCTrack for given particle, add it if it doesn't exist yet.
void	addVertex (const genfit::GFRaveVertex *vertex)
	Add a vertex point and its covariance matrix.
void	addECLCluster (const ECLCluster *cluster)
	Add a reconstructed cluster in the ECL.
void	addKLMCluster (const KLMCluster *cluster)
	Add a reconstructed cluster in the KLM.
void	addBKLMHit2d (const KLMHit2d *bklm2dhit)
	Add a reconstructed 2d hit in the BKLM.
void	addEKLMHit2d (const KLMHit2d *eklm2dhit)
	Add a reconstructed 2d hit in the EKLM.
void	addARICHHit (const ARICHHit *hit)
	Add recontructed hit in ARICH.
void	addROI (const ROIid *roi)
	Add a Region Of Interest, computed by the PXDDataReduction module.
template<class T >
void	addUnassignedRecoHits (const StoreArray< T > &hits)
	After adding recohits for tracks/candidates, this function adds the remaining hits in a global collection.
void	addCDCHit (const CDCHit *hit, bool showTriggerHits=false)
	show CDCHits directly.
void	addCDCTriggerSegmentHit (const std::string &collectionName, const CDCTriggerSegmentHit *hit)
	show outline of track segments.
void	addTOPDigits (const StoreArray< TOPDigit > &digits)
	Add TOPDigits (shown aggregated per module).
void	addObject (const TObject *dataStoreObject, TEveElement *visualRepresentation)
	Generic function to keep track of which objects have which visual representation.
void	showUserData (const DisplayData &displayData)
	Add user-defined data (labels, points, etc.)
void	makeTracks ()
	Create visual representation of all tracks.
void	clearEvent ()
	clear event data.
void	setOptions (const std::string &opts)
	Set the display options.
void	setErrScale (double errScale=1.)
	Set the scaling factor for the visualization of track hit errors.
void	setAssignToPrimaries (bool on)
	If true, hits created by secondary particles (e.g.
void	setHideSecondaries (bool on)
	If true, secondary MCParticles (and hits created by them) will not be shown.

Private Types
enum	eFitterType {   SimpleKalman ,   RefKalman ,   DafSimple ,   DafRef ,   Gbl }
	Fitter type to be used for addTrack(). More...

Private Member Functions
TEveBox *	boxCreator (const ROOT::Math::XYZVector &o, ROOT::Math::XYZVector u, ROOT::Math::XYZVector v, float ud, float vd, float depth)
	Create a box around o, oriented along u and v with widths ud, vd and depth and return a pointer to the box object.
void	makeLines (TEveTrack *eveTrack, const genfit::StateOnPlane *prevState, const genfit::StateOnPlane *state, const genfit::AbsTrackRep *rep, TEvePathMark::EType_e markType, bool drawErrors, int markerPos=1)
	Create hit visualisation for the given options, and add them to 'eveTrack'.
template<class SomeVXDHit >
void	addRecoHit (const SomeVXDHit *hit, TEveStraightLineSet *lines)
	adds given VXD hit to lines.
void	addRecoHit (const SVDCluster *hit, TEveStraightLineSet *lines)
	specialisation for SVDCluster
void	addRecoHit (const CDCHit *hit, TEveStraightLineSet *lines)
	specialisation for CDCHit.
void	addToGroup (const std::string &name, TEveElement *elem)
	Add 'elem' to the element group 'name' (created if necessary).

Private Attributes
TEveCalo3D *	m_calo3d
	Object for the energy bar visualisation.
double	m_errorScale
	Rescale PXD/SVD errors with this factor to ensure visibility.
std::string	m_options
	Option string for genfit::Track visualisation.
bool	m_assignToPrimaries
	If true, hits created by secondary particles (e.g.
bool	m_hideSecondaries {false}
	If true, secondary MCParticles (and hits created by them) will not be shown.
std::map< const MCParticle *, MCTrack >	m_mcparticleTracks
	map MCParticles to MCTrack (so hits can be added to the correct track).
std::map< std::string, ElementGroup >	m_groups
	name -> grouping element.
TEveTrackList *	m_tracklist
	parent object for MC tracks.
TEveTrackPropagator *	m_trackpropagator
	Track propagator for MCParticles.
TEveTrackPropagator *	m_gftrackpropagator
	Track propagator for genfit::Tracks (different mainly because of drawing options)
TEveTrackPropagator *	m_consttrackpropagator
	Track propagator for CDCTriggerTracks (uses constant B field)
TEveCaloDataVec *	m_eclData
	ECL cluster data.
EveVisBField *	m_bfield
	The global magnetic field.
std::set< const TObject * >	m_shownRecohits
	List of shown recohits (PXDCluster, SVDCluster, CDCHit).
TEveStraightLineSet *	m_unassignedRecoHits = nullptr
	Unassigned recohits.
bool	m_unassignedRecoHitsVisibility = true
	is m_unassignedRecoHits visible?
bool	m_drawCardinalRep = true
	Draw cardinal representation in addTrack.
bool	m_drawErrors = false
	Draw errors in addTrack.
bool	m_drawRefTrack = false
	Draw reference track in addTrack.
bool	m_drawForward = false
	draw forward in addTrack
bool	m_drawBackward = false
	draw backward in addTrack

Static Private Attributes
static const int	c_recoHitColor = getTColorID("Orange", 1)
	Color for reco hits.
static const int	c_recoTrackColor = getTColorID("Sky Blue", 1)
	Color for TrackCandidates.
static const int	c_trackColor = getTColorID("Sky Blue", 2)
	Color for tracks.
static const int	c_trackMarkerColor = getTColorID("Chameleon", 3)
	Color for track markers.
static const int	c_unassignedHitColor = getTColorID("Plum", 1)
	Color for unassigned (reco)hits.
static const int	c_klmClusterColor = getTColorID("Chameleon", 1)
	Color for KLMCluster objects.
static constexpr double	c_minPCut = 0.00
	don't show MCParticles with momentum below this cutoff.

Detailed Description

Produces visualisation for MCParticles, simhits, genfit::Tracks, geometry and other things.

Creates TEve objects from the given data, and adds them to the global or event scene.

See also

DisplayModule

Definition at line 63 of file EVEVisualization.h.

Member Enumeration Documentation

eFitterType

enum eFitterType

private

Fitter type to be used for addTrack().

Definition at line 65 of file EVEVisualization.h.

                     {
      SimpleKalman,
      RefKalman,
      DafSimple,
      DafRef,
      Gbl
    };

Constructor & Destructor Documentation

EVEVisualization()

EVEVisualization ( )

explicit

Constructor.

Definition at line 134 of file EVEVisualization.cc.

                                  :
  m_assignToPrimaries(false),
  m_eclData(0),
  m_bfield(new EveVisBField())
{
  setErrScale();
 
  TGLLogicalShape::SetIgnoreSizeForCameraInterest(kTRUE);     // Allows the visualization of the "small" error ellipsoid.
 
  //create new containers
  m_trackpropagator = new TEveTrackPropagator();
  m_trackpropagator->IncDenyDestroy();
  m_trackpropagator->SetMagFieldObj(m_bfield, false);
  m_trackpropagator->SetFitDaughters(false); //most secondaries are no longer immediate daughters since we might discard those!
  m_trackpropagator->SetMaxR(EveGeometry::getMaxR()); //don't draw tracks outside detector
  //TODO is this actually needed?
  m_trackpropagator->SetMaxStep(1.0); //make sure to reeval magnetic field often enough
 
  m_tracklist = new TEveTrackList(m_trackpropagator);
  m_tracklist->IncDenyDestroy();
  m_tracklist->SetName("MCParticles");
  m_tracklist->SelectByP(c_minPCut, FLT_MAX); //don't show too many particles by default...
 
  m_gftrackpropagator = new TEveTrackPropagator();
  m_gftrackpropagator->IncDenyDestroy();
  m_gftrackpropagator->SetMagFieldObj(m_bfield, false);
  m_gftrackpropagator->SetMaxOrbs(0.5); //stop after track markers
 
  m_consttrackpropagator = new TEveTrackPropagator();
  m_consttrackpropagator->IncDenyDestroy();
  m_consttrackpropagator->SetMagField(0, 0, -1.5);
  m_consttrackpropagator->SetMaxR(EveGeometry::getMaxR());
 
  m_calo3d = new TEveCalo3D(NULL, "ECLClusters");
  m_calo3d->SetBarrelRadius(125.80); //inner radius of ECL barrel
  m_calo3d->SetForwardEndCapPos(196.5); //inner edge of forward endcap
  m_calo3d->SetBackwardEndCapPos(-102.0); //inner edge of backward endcap
  m_calo3d->SetMaxValAbs(2.1);
  m_calo3d->SetRnrFrame(false, false); //don't show crystal grid
  m_calo3d->IncDenyDestroy();
 
  //Stop eve from deleting contents... (which might already be deleted)
  gEve->GetSelection()->IncDenyDestroy();
  gEve->GetHighlight()->IncDenyDestroy();
 
  clearEvent();
}

~EVEVisualization()

~EVEVisualization

(

)

Destructor.

Definition at line 186 of file EVEVisualization.cc.

{
  if (!gEve)
    return; //objects are probably already freed by Eve
 
  //Eve objects
  destroyEveElement(m_eclData);
  destroyEveElement(m_unassignedRecoHits);
  destroyEveElement(m_tracklist);
  destroyEveElement(m_trackpropagator);
  destroyEveElement(m_gftrackpropagator);
  destroyEveElement(m_consttrackpropagator);
  destroyEveElement(m_calo3d);
  delete m_bfield;
}

Member Function Documentation

addARICHHit()

void addARICHHit

(

const ARICHHit *

hit

)

Add recontructed hit in ARICH.

Definition at line 1772 of file EVEVisualization.cc.

{
  DBObjPtr<ARICHGeometryConfig> arichGeo;
 
  int hitModule = hit->getModule();
  float fi = arichGeo->getDetectorPlane().getSlotPhi(hitModule);
 
  ROOT::Math::XYZVector  centerPos3D =  hit->getPosition();
 
  ROOT::Math::RotationZ rotZ(fi);
  ROOT::Math::XYZVector channelX(1, 0, 0);
  ROOT::Math::XYZVector channelY(0, 1, 0);
  channelX = rotZ * channelX;
  channelY = rotZ * channelY;
 
  auto* arichbox = boxCreator(centerPos3D,
                              arichGeo->getMasterVolume().momentumToGlobal(channelX),
                              arichGeo->getMasterVolume().momentumToGlobal(channelY),
                              0.49, 0.49, 0.05);
  arichbox->SetMainColor(kOrange + 10);
  arichbox->SetName((std::to_string(hitModule)).c_str());
 
  addToGroup("ARICHHits", arichbox);
  addObject(hit, arichbox);
}

addBKLMHit2d()

void addBKLMHit2d

(

const KLMHit2d *

bklm2dhit

)

Add a reconstructed 2d hit in the BKLM.

Definition at line 1494 of file EVEVisualization.cc.

{
  bklm::GeometryPar*  m_GeoPar = Belle2::bklm::GeometryPar::instance();
  const bklm::Module* module = m_GeoPar->findModule(bklm2dhit->getSection(), bklm2dhit->getSector(), bklm2dhit->getLayer());
 
  CLHEP::Hep3Vector global;
  //+++ global coordinates of the hit
  global[0] = bklm2dhit->getPositionX();
  global[1] = bklm2dhit->getPositionY();
  global[2] = bklm2dhit->getPositionZ();
 
  //+++ local coordinates of the hit
  CLHEP::Hep3Vector local = module->globalToLocal(global);
  //double localU = local[1]; //phi
  //double localV = local[2]; //z
  int Nphistrip = bklm2dhit->getPhiStripMax() - bklm2dhit->getPhiStripMin() + 1;
  int Nztrip = bklm2dhit->getZStripMax() - bklm2dhit->getZStripMin() + 1;
  double du = module->getPhiStripWidth() * Nphistrip;
  double dv = module->getZStripWidth() * Nztrip;
 
  //Let's do some simple thing
  CLHEP::Hep3Vector localU(local[0], local[1] + 1.0, local[2]);
  CLHEP::Hep3Vector localV(local[0], local[1], local[2] + 1.0);
 
  CLHEP::Hep3Vector globalU = module->localToGlobal(localU);
  CLHEP::Hep3Vector globalV = module->localToGlobal(localV);
 
  ROOT::Math::XYZVector o(global[0], global[1], global[2]);
  ROOT::Math::XYZVector u(globalU[0], globalU[1], globalU[2]);
  ROOT::Math::XYZVector v(globalV[0], globalV[1], globalV[2]);
 
  //Lest's just assign the depth is 1.0 cm (thickness of a layer), better to update
  TEveBox* bklmbox = boxCreator(o, u - o, v - o, du, dv, 1.0);
 
  bklmbox->SetMainColor(kGreen);
  //bklmbox->SetName((std::to_string(hitModule)).c_str());
  bklmbox->SetName("BKLMHit2d");
 
  addToGroup("BKLM2dHits", bklmbox);
  addObject(bklm2dhit, bklmbox);
}

addCDCHit()

void addCDCHit	(	const CDCHit *	hit,
		bool	showTriggerHits = false
	)

show CDCHits directly.

Definition at line 1613 of file EVEVisualization.cc.

{
  static CDC::CDCGeometryPar& cdcgeo = CDC::CDCGeometryPar::Instance();
  const B2Vector3D& wire_pos_f = cdcgeo.wireForwardPosition(WireID(hit->getID()));
  const B2Vector3D& wire_pos_b = cdcgeo.wireBackwardPosition(WireID(hit->getID()));
  static CDC::RealisticTDCCountTranslator tdcTranslator;
  TEveGeoShape* cov_shape = new TEveGeoShape("cov_shape");
  //TODO: leftrightflag not set! (same for other parameters, unsure which ones should be set)
  double driftLength = tdcTranslator.getDriftLength(hit->getTDCCount(), WireID(hit->getID()));
  double driftLengthRes = tdcTranslator.getDriftLengthResolution(driftLength, WireID(hit->getID()));
  driftLengthRes = std::max(driftLengthRes, 0.005);
  const double lengthOfWireSection = 3.0;
 
  //z in wire direction, x,y orthogonal
  const B2Vector3D zaxis = wire_pos_b - wire_pos_f;
  const B2Vector3D xaxis = zaxis.Orthogonal();
  const B2Vector3D yaxis = xaxis.Cross(zaxis);
 
  // move to z=0
  const B2Vector3D midPoint = wire_pos_f - zaxis * (wire_pos_f.Z() / zaxis.Z());
 
  cov_shape->SetShape(new TGeoTube(std::max(0., (double)(driftLength - driftLengthRes)), driftLength + driftLengthRes,
                                   lengthOfWireSection));
  fixGeoShapeRefCount(cov_shape);
 
  TGeoRotation det_rot("det_rot",
                       xaxis.Theta() * 180 / TMath::Pi(), xaxis.Phi() * 180 / TMath::Pi(),
                       yaxis.Theta() * 180 / TMath::Pi(), yaxis.Phi() * 180 / TMath::Pi(),
                       zaxis.Theta() * 180 / TMath::Pi(), zaxis.Phi() * 180 / TMath::Pi()
                      );
 
  TGeoCombiTrans det_trans(midPoint.X(), midPoint.Y(), midPoint.Z(), &det_rot);
  cov_shape->SetTransMatrix(det_trans);
 
  // get relation to trigger track segments
  bool isPartOfTS = false;
  const auto segments = hit->getRelationsFrom<CDCTriggerSegmentHit>();
  if (showTriggerHits && segments.size() > 0) {
    isPartOfTS = true;
  }
 
  if (hit->getISuperLayer() % 2 == 0) {
    if (isPartOfTS)
      cov_shape->SetMainColor(kCyan + 3);
    else
      cov_shape->SetMainColor(kCyan);
  } else {
    if (isPartOfTS)
      cov_shape->SetMainColor(kPink + 6);
    else
      cov_shape->SetMainColor(kPink + 7);
  }
 
  cov_shape->SetMainTransparency(50);
  cov_shape->SetName(ObjectInfo::getIdentifier(hit));
  cov_shape->SetTitle(ObjectInfo::getInfo(hit) + TString::Format("\nWire ID: %d\nADC: %d\nTDC: %d",
                      hit->getID(), hit->getADCCount(), hit->getTDCCount()));
 
  addToGroup("CDCHits", cov_shape);
  addObject(hit, cov_shape);
  if (isPartOfTS) {
    addToGroup("CDCTriggerSegmentHits", cov_shape);
    for (auto rel : segments.relations()) {
      addObject(rel.object, cov_shape);
    }
  }
}

addCDCTriggerSegmentHit()

void addCDCTriggerSegmentHit	(	const std::string &	collectionName,
		const CDCTriggerSegmentHit *	hit
	)

show outline of track segments.

Definition at line 1681 of file EVEVisualization.cc.

{
  static CDC::CDCGeometryPar& cdcgeo = CDC::CDCGeometryPar::Instance();
  TEveStraightLineSet* shape = new TEveStraightLineSet();
 
  // get center wire
  unsigned iL = WireID(hit->getID()).getICLayer();
  if (hit->getPriorityPosition() < 3) iL -= 1;
  unsigned nWires = cdcgeo.nWiresInLayer(iL);
  unsigned iCenter = hit->getIWire();
  if (hit->getPriorityPosition() == 1) iCenter += 1;
 
  // a track segment consists of 11 wires (15 in SL0) in a special configuration
  // -> get the shift with respect to the center wire (*) for all wires
  // SL 1-8:
  //  _ _ _
  // |_|_|_|
  //  |_|_|
  //   |*|
  //  |_|_|
  // |_|_|_|
  std::vector<int> layershift = { -2, -1, 0, 1, 2};
  std::vector<std::vector<float>> cellshift = {
    { -1, 0, 1},
    { -0.5, 0.5},
    { 0},
    { -0.5, 0.5},
    { -1, 0, 1}
  };
  // SL 0:
  //  _ _ _ _ _
  // |_|_|_|_|_|
  //  |_|_|_|_|
  //   |_|_|_|
  //    |_|_|
  //     |*|
  if (hit->getISuperLayer() == 0) {
    layershift = { 0, 1, 2, 3, 4};
    cellshift = {
      { 0},
      { -0.5, 0.5},
      { -1, 0, 1},
      { -1.5, -0.5, 0.5, 1.5},
      { -2, -1, 0, 1, 2}
    };
  }
 
  // draw all cells in segment
  for (unsigned il = 0; il < layershift.size(); ++il) {
    for (unsigned ic = 0; ic < cellshift[il].size(); ++ic) {
      ROOT::Math::XYZVector corners[2][2];
      for (unsigned ir = 0; ir < 2; ++ir) {
        double r = cdcgeo.fieldWireR(iL + layershift[il] - ir);
        double fz = cdcgeo.fieldWireFZ(iL + layershift[il] - ir);
        double bz = cdcgeo.fieldWireBZ(iL + layershift[il] - ir);
        for (unsigned iphi = 0; iphi < 2; ++iphi) {
          double phib = (iCenter + cellshift[il][ic] + iphi - 0.5) * 2 * M_PI / nWires;
          double phif = phib + cdcgeo.nShifts(iL + layershift[il]) * M_PI / nWires;
 
          ROOT::Math::XYZVector pos_f = ROOT::Math::XYZVector(cos(phif) * r, sin(phif) * r, fz);
          ROOT::Math::XYZVector pos_b = ROOT::Math::XYZVector(cos(phib) * r, sin(phib) * r, bz);
          ROOT::Math::XYZVector zaxis = pos_b - pos_f;
          corners[ir][iphi] = pos_f - zaxis * (pos_f.Z() / zaxis.Z());
        }
      }
 
      shape->AddLine(corners[0][0].X(), corners[0][0].Y(), 0,
                     corners[0][1].X(), corners[0][1].Y(), 0);
      shape->AddLine(corners[0][1].X(), corners[0][1].Y(), 0,
                     corners[1][1].X(), corners[1][1].Y(), 0);
      shape->AddLine(corners[1][1].X(), corners[1][1].Y(), 0,
                     corners[1][0].X(), corners[1][0].Y(), 0);
      shape->AddLine(corners[1][0].X(), corners[1][0].Y(), 0,
                     corners[0][0].X(), corners[0][0].Y(), 0);
    }
  }
 
  if (hit->getISuperLayer() % 2 == 0) {
    shape->SetMainColor(kCyan + 3);
  } else {
    shape->SetMainColor(kPink + 6);
  }
 
  shape->SetName(ObjectInfo::getIdentifier(hit));
  shape->SetTitle(ObjectInfo::getTitle(hit) +
                  TString::Format("\nPriority: %d\nLeft/Right: %d",
                                  hit->getPriorityPosition(), hit->getLeftRight()));
  addToGroup(collectionName, shape);
  addObject(hit, shape);
}

addCDCTriggerTrack()

void addCDCTriggerTrack	(	const std::string &	collectionName,
		const CDCTriggerTrack &	track
	)

Add a CDCTriggerTrack.

Definition at line 346 of file EVEVisualization.cc.

{
  const TString label = ObjectInfo::getIdentifier(&trgTrack);
 
  B2Vector3D track_pos = B2Vector3D(0, 0, trgTrack.getZ0());
  B2Vector3D track_mom = (trgTrack.getChargeSign() == 0) ?
                         trgTrack.getDirection() * 1000 :
                         trgTrack.getMomentum(1.5);
 
  TEveRecTrack rectrack;
  rectrack.fP.Set(track_mom);
  rectrack.fV.Set(track_pos);
 
  TEveTrack* track_lines = new TEveTrack(&rectrack, m_consttrackpropagator);
  track_lines->SetName(label); //popup label set at end of function
  track_lines->SetPropagator(m_consttrackpropagator);
  track_lines->SetLineColor(kOrange + 2);
  track_lines->SetLineWidth(1);
  track_lines->SetTitle(ObjectInfo::getTitle(&trgTrack) +
                        TString::Format("\ncharge: %d, phi: %.2fdeg, pt: %.2fGeV, theta: %.2fdeg, z: %.2fcm",
                                        trgTrack.getChargeSign(),
                                        trgTrack.getPhi0() * 180 / M_PI,
                                        trgTrack.getTransverseMomentum(1.5),
                                        trgTrack.getDirection().Theta() * 180 / M_PI,
                                        trgTrack.getZ0()));
 
 
  track_lines->SetCharge(trgTrack.getChargeSign());
 
  // show 2D tracks with dashed lines
  if (trgTrack.getZ0() == 0 && trgTrack.getCotTheta() == 0)
    track_lines->SetLineStyle(2);
 
  addToGroup(collectionName, track_lines);
  addObject(&trgTrack, track_lines);
}

addECLCluster()

void addECLCluster

(

const ECLCluster *

cluster

)

Add a reconstructed cluster in the ECL.

Definition at line 1403 of file EVEVisualization.cc.

{
 
  // only display c_nPhotons hypothesis clusters
  if (cluster->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) {
 
    const float phi = cluster->getPhi();
    float dPhi = cluster->getUncertaintyPhi();
    float dTheta = cluster->getUncertaintyTheta();
    if (dPhi >= M_PI / 4 or dTheta >= M_PI / 4 or cluster->getUncertaintyEnergy() == 1.0) {
      B2WARNING("Found ECL cluster with broken errors (unit matrix or too large). Using 0.05 as error in phi/theta. The 3x3 error matrix previously was:");
      cluster->getCovarianceMatrix3x3().Print();
      dPhi = dTheta = 0.05;
    }
 
    if (!std::isfinite(dPhi) or !std::isfinite(dTheta)) {
      B2ERROR("ECLCluster phi or theta error is NaN or infinite, skipping cluster!");
      return;
    }
 
    //convert theta +- dTheta into eta +- dEta
    ROOT::Math::XYZVector thetaLow;
    VectorUtil::setPtThetaPhi(thetaLow, 1.0, cluster->getTheta() - dTheta, phi);
    ROOT::Math::XYZVector thetaHigh;
    VectorUtil::setPtThetaPhi(thetaHigh, 1.0, cluster->getTheta() + dTheta, phi);
    float etaLow = thetaLow.Eta();
    float etaHigh = thetaHigh.Eta();
    if (etaLow > etaHigh) {
      std::swap(etaLow, etaHigh);
    }
 
    int id = m_eclData->AddTower(etaLow, etaHigh, phi - dPhi, phi + dPhi);
    m_eclData->FillSlice(0, cluster->getEnergy(ECLCluster::EHypothesisBit::c_nPhotons));
    VisualRepMap::getInstance()->addCluster(cluster, m_eclData, id);
  }
}

addEKLMHit2d()

void addEKLMHit2d

(

const KLMHit2d *

eklm2dhit

)

Add a reconstructed 2d hit in the EKLM.

Definition at line 1536 of file EVEVisualization.cc.

{
  const double du = 2.0;
  const double dv = 2.0;
  ROOT::Math::XYZVector hitPosition = eklm2dhit->getPosition();
  ROOT::Math::XYZVector o(hitPosition.X(), hitPosition.Y(), hitPosition.Z());
  ROOT::Math::XYZVector u(1.0, 0.0, 0.0);
  ROOT::Math::XYZVector v(0.0, 1.0, 0.0);
  TEveBox* eklmbox = boxCreator(o, u, v, du, dv, 4.0);
  eklmbox->SetMainColor(kGreen);
  eklmbox->SetName("EKLMHit2d");
  addToGroup("EKLM2dHits", eklmbox);
  addObject(eklm2dhit, eklmbox);
}

addKLMCluster()

void addKLMCluster

(

const KLMCluster *

cluster

)

Add a reconstructed cluster in the KLM.

Definition at line 1440 of file EVEVisualization.cc.

{
  const double layerThicknessCm = 3.16; //TDR, Fig 10.2
  const double layerDistanceCm = 9.1 - layerThicknessCm;
 
  // Pposition of first RPC plane.
  ROOT::Math::XYZVector position = cluster->getClusterPosition();
  ROOT::Math::XYZVector startPos(position.X(), position.Y(), position.Z());
  ROOT::Math::XYZVector dir; //direction of cluster stack, Mag() == distance between planes
  ROOT::Math::XYZVector a, b; //defines RPC plane
  bool isBarrel = (startPos.Z() > -175.0 and startPos.Z() < 270.0);
  if (isBarrel) {
    //barrel
    b = ROOT::Math::XYZVector(0, 0, 1);
    a = startPos.Cross(b).Unit();
    double c = M_PI / 4.0;
    double offset = c / 2.0 + M_PI;
    VectorUtil::setPhi(a, int((a.Phi() + offset) / (c))*c - M_PI);
    ROOT::Math::XYZVector perp = b.Cross(a);
 
    const double barrelRadiusCm = 204.0;
    VectorUtil::setMag(startPos, barrelRadiusCm / perp.Dot(startPos.Unit()));
 
    dir = startPos.Unit();
    VectorUtil::setMag(dir, (layerDistanceCm + layerThicknessCm) / perp.Dot(dir));
  } else {
    //endcap
    b = ROOT::Math::XYZVector(startPos.X(), startPos.Y(), 0).Unit();
    a = startPos.Cross(b).Unit();
    double endcapStartZ = 284;
    if (startPos.Z() < 0)
      endcapStartZ = -189.5;
 
    double scaleFac = endcapStartZ / startPos.Z();
    VectorUtil::setMag(startPos, startPos.R() * scaleFac);
 
    dir = startPos.Unit();
    VectorUtil::setMag(dir, (layerDistanceCm + layerThicknessCm) / fabs(dir.Z()));
  }
 
  for (int i = 0; i < cluster->getLayers(); i++) {
    ROOT::Math::XYZVector layerPos = startPos;
    layerPos += (cluster->getInnermostLayer() + i) * dir;
    auto* layer = boxCreator(layerPos, a, b, 20.0, 20.0, layerThicknessCm / 2);
    layer->SetMainColor(c_klmClusterColor);
    layer->SetMainTransparency(70);
    layer->SetName(ObjectInfo::getIdentifier(cluster));
    layer->SetTitle(ObjectInfo::getTitle(cluster));
 
    addToGroup(std::string("KLMClusters/") + ObjectInfo::getIdentifier(cluster).Data(), layer);
    addObject(cluster, layer);
  }
}

addMCParticle()

EVEVisualization::MCTrack * addMCParticle

(

const MCParticle *

particle

)

Return MCTrack for given particle, add it if it doesn't exist yet.

If particle is NULL, a dummy MCTrack (with track=0) is created which can accept otherwise unassigned hits. Returns NULL if this particle and its hits shouldn't be shown.

Definition at line 1102 of file EVEVisualization.cc.

{
  if (!particle) {
    if (!m_mcparticleTracks[nullptr].simhits) {
      const TString pointsTitle("Unassigned SimHits");
      m_mcparticleTracks[nullptr].simhits = new TEvePointSet(pointsTitle);
      m_mcparticleTracks[nullptr].simhits->SetTitle(pointsTitle);
      m_mcparticleTracks[nullptr].simhits->SetMarkerStyle(6);
      m_mcparticleTracks[nullptr].simhits->SetMainColor(c_unassignedHitColor);
      //m_mcparticleTracks[nullptr].simhits->SetMainTransparency(50);
      m_mcparticleTracks[nullptr].track = NULL;
    }
    return &m_mcparticleTracks[nullptr];
  }
 
  if (m_hideSecondaries and !particle->hasStatus(MCParticle::c_PrimaryParticle)) {
    return NULL;
  }
  if (m_assignToPrimaries) {
    while (!particle->hasStatus(MCParticle::c_PrimaryParticle) and particle->getMother())
      particle = particle->getMother();
  }
 
  if (!m_mcparticleTracks[particle].track) {
    const ROOT::Math::XYZVector& p = particle->getMomentum();
    const ROOT::Math::XYZVector& vertex = particle->getProductionVertex();
    const int pdg = particle->getPDG();
    TParticle tparticle(pdg, particle->getStatus(),
                        (particle->getMother() ? particle->getMother()->getIndex() : 0), 0, particle->getFirstDaughter(), particle->getLastDaughter(),
                        p.X(), p.Y(), p.Z(), particle->getEnergy(),
                        vertex.X(), vertex.Y(), vertex.Z(), particle->getProductionTime());
    TEveMCTrack mctrack;
    mctrack = tparticle;
    mctrack.fTDecay = particle->getDecayTime();
    mctrack.fVDecay.Set(B2Vector3D(particle->getDecayVertex()));
    mctrack.fDecayed = !std::isinf(mctrack.fTDecay);
    mctrack.fIndex = particle->getIndex();
    m_mcparticleTracks[particle].track = new TEveTrack(&mctrack, m_trackpropagator);
 
    //Check if there is a trajectory stored for this particle
    const auto mcTrajectories = particle->getRelationsTo<MCParticleTrajectory>();
    bool hasTrajectory(false);
    for (auto rel : mcTrajectories.relations()) {
      //Trajectories with negative weight are from secondary daughters which
      //were ignored so we don't use them.
      if (rel.weight <= 0)  continue;
      //Found one, let's add tose point as reference points to the TEveTrack.
      //This will force the track propagation to visit all points in order but
      //provide smooth helix interpolation between the points
      const MCParticleTrajectory& trajectory = dynamic_cast<const MCParticleTrajectory&>(*rel.object);
      for (const MCTrajectoryPoint& pt : trajectory) {
        m_mcparticleTracks[particle].track->AddPathMark(
          TEvePathMark(
            //Add the last trajectory point as decay point to prevent TEve to
            //propagate beyond the end of the track. So lets compare the adress
            //to the address of last point and choose the pathmark accordingly
            (&pt == &trajectory.back()) ? TEvePathMark::kDecay : TEvePathMark::kReference,
            TEveVector(pt.x, pt.y, pt.z),
            TEveVector(pt.px, pt.py, pt.pz)
          ));
      }
      //"There can only be One" -> found a trajectory, stop the loop
      hasTrajectory = true;
      break;
    }
 
    //If we have the full trajectory there is no need to add additional path marks
    if (!hasTrajectory) {
      //add daughter vertices - improves track rendering as lost momentum is taken into account
      for (int iDaughter = particle->getFirstDaughter(); iDaughter <= particle->getLastDaughter(); iDaughter++) {
        if (iDaughter == 0)
          continue; //no actual daughter
 
        const MCParticle* daughter = StoreArray<MCParticle>()[iDaughter - 1];
 
        TEvePathMarkD refMark(TEvePathMarkD::kDaughter);
        refMark.fV.Set(B2Vector3D(daughter->getProductionVertex()));
        refMark.fP.Set(B2Vector3D(daughter->getMomentum()));
        refMark.fTime = daughter->getProductionTime();
        m_mcparticleTracks[particle].track->AddPathMark(refMark);
      }
 
      //neutrals and very short-lived particles should stop somewhere
      //(can result in wrong shapes for particles stopped in the detector, so not used there)
      if ((TMath::Nint(particle->getCharge()) == 0 or !particle->hasStatus(MCParticle::c_StoppedInDetector))
          and mctrack.fDecayed) {
        TEvePathMarkD decayMark(TEvePathMarkD::kDecay);
        decayMark.fV.Set(B2Vector3D(particle->getDecayVertex()));
        m_mcparticleTracks[particle].track->AddPathMark(decayMark);
      }
    }
    TString particle_name(mctrack.GetName());
 
    //set track title (for popup)
    const MCParticle* mom = particle->getMother();
    if (mom) {
      m_mcparticleTracks[particle].parentParticle = mom;
      addMCParticle(mom);
    }
 
    TString title = ObjectInfo::getTitle(particle);
    if (!hasTrajectory) {
      //Hijack the mother label to show that the track position is only
      //extrapolated, not known from simulation
      title += "\n(track estimated from initial momentum)";
      //Also, show those tracks with dashed lines
      m_mcparticleTracks[particle].track->SetLineStyle(2);
    }
 
    m_mcparticleTracks[particle].track->SetTitle(title);
 
    //add some color (avoid black & white)
    switch (abs(pdg)) {
      case 11:
        m_mcparticleTracks[particle].track->SetLineColor(kAzure);
        break;
      case 13:
        m_mcparticleTracks[particle].track->SetLineColor(kCyan + 1);
        break;
      case 22:
        m_mcparticleTracks[particle].track->SetLineColor(kSpring);
        break;
      case 211:
        m_mcparticleTracks[particle].track->SetLineColor(kGray + 1);
        break;
      case 321:
        m_mcparticleTracks[particle].track->SetLineColor(kRed + 1);
        break;
      case 2212:
        m_mcparticleTracks[particle].track->SetLineColor(kOrange - 2);
        break;
      default:
        m_mcparticleTracks[particle].track->SetLineColor(kMagenta);
    }
 
    //create point set for hits
    const TString pointsTitle = "SimHits for " + ObjectInfo::getIdentifier(particle) + " - " + particle_name;
    m_mcparticleTracks[particle].simhits = new TEvePointSet(pointsTitle);
    m_mcparticleTracks[particle].simhits->SetTitle(pointsTitle);
    m_mcparticleTracks[particle].simhits->SetMarkerStyle(6);
    m_mcparticleTracks[particle].simhits->SetMainColor(m_mcparticleTracks[particle].track->GetLineColor());
    //m_mcparticleTracks[particle].simhits->SetMainTransparency(50);
    addObject(particle, m_mcparticleTracks[particle].track);
  }
  return &m_mcparticleTracks[particle];
}

addObject()

void addObject	(	const TObject *	dataStoreObject,
		TEveElement *	visualRepresentation
	)

Generic function to keep track of which objects have which visual representation.

Should be called by functions adding TEveElements to the event scene (Hits are currently excluded).

Definition at line 1906 of file EVEVisualization.cc.

{
  VisualRepMap::getInstance()->add(dataStoreObject, visualRepresentation);
}

addRecoHit() [1/3]

void addRecoHit ( const CDCHit *  hit, TEveStraightLineSet *  lines  )

private

specialisation for CDCHit.

Definition at line 1602 of file EVEVisualization.cc.

{
  static CDC::CDCGeometryPar& cdcgeo = CDC::CDCGeometryPar::Instance();
  const ROOT::Math::XYZVector& wire_pos_f = cdcgeo.wireForwardPosition(WireID(hit->getID()));
  const ROOT::Math::XYZVector& wire_pos_b = cdcgeo.wireBackwardPosition(WireID(hit->getID()));
 
  lines->AddLine(wire_pos_f.X(), wire_pos_f.Y(), wire_pos_f.Z(), wire_pos_b.X(), wire_pos_b.Y(), wire_pos_b.Z());
  m_shownRecohits.insert(hit);
 
}

addRecoHit() [2/3]

void addRecoHit ( const SomeVXDHit *  hit, TEveStraightLineSet *  lines  )

inlineprivate

adds given VXD hit to lines.

Definition at line 289 of file EVEVisualization.h.

    {
      static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
 
      const ROOT::Math::XYZVector local_pos(hit->getU(), hit->getV(), 0.0); //z-component is height over the center of the detector plane
      const VXD::SensorInfoBase& sensor = geo.getSensorInfo(hit->getSensorID());
      const ROOT::Math::XYZVector global_pos = sensor.pointToGlobal(local_pos);
      lines->AddMarker(global_pos.X(), global_pos.Y(), global_pos.Z());
 
      m_shownRecohits.insert(hit);
    }

addRecoHit() [3/3]

void addRecoHit ( const SVDCluster *  hit, TEveStraightLineSet *  lines  )

private

specialisation for SVDCluster

Definition at line 1582 of file EVEVisualization.cc.

{
  static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
  const VXD::SensorInfoBase& sensor = geo.getSensorInfo(hit->getSensorID());
 
  ROOT::Math::XYZVector a, b;
  if (hit->isUCluster()) {
    const float u = hit->getPosition();
    a = sensor.pointToGlobal(ROOT::Math::XYZVector(sensor.getBackwardWidth() / sensor.getWidth(0) * u, -0.5 * sensor.getLength(), 0.0));
    b = sensor.pointToGlobal(ROOT::Math::XYZVector(sensor.getForwardWidth() / sensor.getWidth(0) * u, +0.5 * sensor.getLength(), 0.0));
  } else {
    const float v = hit->getPosition();
    a = sensor.pointToGlobal(ROOT::Math::XYZVector(-0.5 * sensor.getWidth(v), v, 0.0));
    b = sensor.pointToGlobal(ROOT::Math::XYZVector(+0.5 * sensor.getWidth(v), v, 0.0));
  }
 
  lines->AddLine(a.X(), a.Y(), a.Z(), b.X(), b.Y(), b.Z());
  m_shownRecohits.insert(hit);
}

addROI()

void addROI

(

const ROIid *

roi

)

Add a Region Of Interest, computed by the PXDDataReduction module.

Definition at line 1551 of file EVEVisualization.cc.

{
  const VXD::GeoCache& aGeometry = VXD::GeoCache::getInstance();
 
  VxdID sensorID = roi->getSensorID();
  const VXD::SensorInfoBase& aSensorInfo = aGeometry.getSensorInfo(sensorID);
 
  double minU = aSensorInfo.getUCellPosition(roi->getMinUid(), roi->getMinVid());
  double minV = aSensorInfo.getVCellPosition(roi->getMinVid());
  double maxU = aSensorInfo.getUCellPosition(roi->getMaxUid(), roi->getMaxVid());
  double maxV = aSensorInfo.getVCellPosition(roi->getMaxVid());
 
 
  ROOT::Math::XYZVector localA(minU, minV, 0);
  ROOT::Math::XYZVector localB(minU, maxV, 0);
  ROOT::Math::XYZVector localC(maxU, minV, 0);
 
  ROOT::Math::XYZVector globalA = aSensorInfo.pointToGlobal(localA);
  ROOT::Math::XYZVector globalB = aSensorInfo.pointToGlobal(localB);
  ROOT::Math::XYZVector globalC = aSensorInfo.pointToGlobal(localC);
 
  TEveBox* ROIbox = boxCreator(globalB + globalC * 0.5, globalB - globalA, globalC - globalA, 1, 1, 0.01);
 
  ROIbox->SetName(ObjectInfo::getIdentifier(roi));
  ROIbox->SetMainColor(kSpring - 9);
  ROIbox->SetMainTransparency(50);
 
  addToGroup("ROIs", ROIbox);
  addObject(roi, ROIbox);
}

addSimHit() [1/5]

void addSimHit	(	const CDCSimHit *	hit,
		const MCParticle *	particle
	)

Add a CDCSimHit.

Definition at line 1073 of file EVEVisualization.cc.

{
  addSimHit(ROOT::Math::XYZVector(hit->getPosWire()), particle);
}

addSimHit() [2/5]

void addSimHit	(	const KLMSimHit *	hit,
		const MCParticle *	particle
	)

Add a KLMSimHit.

Definition at line 1089 of file EVEVisualization.cc.

{
  const ROOT::Math::XYZVector& global_pos = hit->getPosition();
  addSimHit(global_pos, particle);
}

addSimHit() [3/5]

void addSimHit	(	const PXDSimHit *	hit,
		const MCParticle *	particle
	)

Add a PXDSimHit.

Definition at line 1077 of file EVEVisualization.cc.

{
  static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
  const ROOT::Math::XYZVector& global_pos = geo.getSensorInfo(hit->getSensorID()).pointToGlobal(hit->getPosIn());
  addSimHit(global_pos, particle);
}

addSimHit() [4/5]

void addSimHit	(	const ROOT::Math::XYZVector &	v,
		const MCParticle *	particle
	)

Add simhit as a simple point.

Definition at line 1094 of file EVEVisualization.cc.

{
  MCTrack* track = addMCParticle(particle);
  if (!track)
    return; //hide hits from this particle
  track->simhits->SetNextPoint(v.X(), v.Y(), v.Z());
}

addSimHit() [5/5]

void addSimHit	(	const SVDSimHit *	hit,
		const MCParticle *	particle
	)

Add a SVDSimHit.

Definition at line 1083 of file EVEVisualization.cc.

{
  static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
  const ROOT::Math::XYZVector& global_pos = geo.getSensorInfo(hit->getSensorID()).pointToGlobal(hit->getPosIn());
  addSimHit(global_pos, particle);
}

addSimHits()

void addSimHits ( const StoreArray< T > &  hits )

inline

Add all entries in the given 'hits' array (and the corresponding MCParticles) to the event scene.

Definition at line 135 of file EVEVisualization.h.

    {
      const int numHits = hits.getEntries();
      for (int i = 0; i < numHits; i++) {
        const RelationsObject* rel = hits[i];
        const MCParticle* mcpart = rel->getRelatedFrom<MCParticle>();
 
        addSimHit(hits[i], mcpart);
      }
    }

addToGroup()

void addToGroup ( const std::string &  name, TEveElement *  elem  )

private

Add 'elem' to the element group 'name' (created if necessary).

name can also be a path, e.g. MyOwnStuff/SpecialObject A, which will automatically create sub-groups.

slashes at beginning and end of name are ignored.

Definition at line 1911 of file EVEVisualization.cc.

{
  //slashes at beginning and end are ignored
  const std::string& groupName = boost::algorithm::trim_copy_if(name, boost::algorithm::is_any_of("/"));
 
  TEveElementList* group = m_groups[groupName].group;
  if (!group) {
    group = new TEveElementList(groupName.c_str(), groupName.c_str());
    group->SetRnrState(m_groups[groupName].visible);
    m_groups[groupName].group = group;
 
    //if groupName contains '/', remove last bit and add to parent group
    //e.g. if groupName=A/B/C, call addToGroup("A/B", groupC)
    auto lastSlash = boost::algorithm::find_last(groupName, "/");
    if (lastSlash) {
      const std::string parentGroup(groupName.begin(), lastSlash.begin());
      const std::string thisGroup(lastSlash.end(), groupName.end());
      group->SetElementName(thisGroup.c_str());
      addToGroup(parentGroup, group);
    } else {
      gEve->AddElement(group);
    }
  }
  group->AddElement(elem);
}

addTOPDigits()

void addTOPDigits

(

const StoreArray< TOPDigit > &

digits

)

Add TOPDigits (shown aggregated per module).

Definition at line 1798 of file EVEVisualization.cc.

{
  /* TOP module ID -> #digits */
  std::map<int, int> m_topSummary;
  for (const TOPDigit& hit : digits) {
    int mod = hit.getModuleID();
    ++m_topSummary[mod];
  }
  int maxcount = 0;
  for (auto modCountPair : m_topSummary) {
    if (modCountPair.second > maxcount)
      maxcount = modCountPair.second;
  }
  for (auto modCountPair : m_topSummary) {
    const auto& topmod = TOP::TOPGeometryPar::Instance()->getGeometry()->getModule(modCountPair.first);
    double phi = topmod.getPhi();
    double r_center = topmod.getRadius();
    double z = topmod.getZc();
 
    ROOT::Math::XYZVector centerPos3D;
    VectorUtil::setMagThetaPhi(centerPos3D, r_center, M_PI / 2, phi);
    centerPos3D.SetZ(z);
 
    B2Vector3D channelX(1, 0, 0);     channelX.RotateZ(phi);
    B2Vector3D channelY(0, 1, 0);     channelY.RotateZ(phi);
 
    //bar is a bit thicker so we can mouse over without getting the geometry
    auto* moduleBox = boxCreator(centerPos3D, channelX, channelY,
                                 3.0 * topmod.getBarThickness(), topmod.getBarWidth(), topmod.getBarLength());
    moduleBox->SetMainColor(kAzure + 10);
    double weight = double(modCountPair.second) / maxcount;
    moduleBox->SetMainTransparency(90 - weight * 50);
    moduleBox->SetName(("TOP module " + std::to_string(modCountPair.first)).c_str());
    moduleBox->SetTitle(TString::Format("#TOPDigits: %d ", modCountPair.second));
 
    addToGroup("TOP Modules", moduleBox);
    //associate all TOPDigits with this module.
    for (const TOPDigit& hit : digits) {
      if (modCountPair.first == hit.getModuleID())
        addObject(&hit, moduleBox);
    }
  }
}

addTrack()

void addTrack

(

const Belle2::Track *

belle2Track

)

Add this genfit::Track to event data.

Adapted from GenfitDisplay, originally written by Karl Bicker.

Definition at line 384 of file EVEVisualization.cc.

{
  // load the pion fit hypothesis or the hypothesis which is the closest in mass to a pion
  // the tracking will not always successfully fit with a pion hypothesis
  const TrackFitResult* fitResult = belle2Track->getTrackFitResultWithClosestMass(Const::pion);
  if (!fitResult) {
    B2ERROR("Track without TrackFitResult skipped.");
    return;
  }
  const RecoTrack* track = belle2Track->getRelated<RecoTrack>();
 
  const TString label = ObjectInfo::getIdentifier(belle2Track) + " (" + ObjectInfo::getIdentifier(fitResult) + ")";
 
  // parse the option string ------------------------------------------------------------------------
  bool drawDetectors = false;
  bool drawHits = false;
  bool drawPlanes = false;
 
  if (m_options != "") {
    for (size_t i = 0; i < m_options.length(); i++) {
      if (m_options.at(i) == 'D') drawDetectors = true;
      if (m_options.at(i) == 'H') drawHits = true;
      if (m_options.at(i) == 'P') drawPlanes = true;
    }
  }
  // finished parsing the option string -------------------------------------------------------------
 
  // We loop over all points (scattering non-measurement points for GBL)
  // and for Kalman we skip those with no measurements, which should
  // not be there
  bool isPruned = (track == nullptr);
 
 
  TEveRecTrackD recTrack;
  const B2Vector3D& poca = fitResult->getPosition();
  recTrack.fV.Set(poca);
 
  const B2Vector3D& poca_momentum = fitResult->getMomentum();
  if (std::isfinite(poca_momentum.Mag()))
    recTrack.fP.Set(poca_momentum);
  else //use 1TeV momentum for tracks without curvature
    recTrack.fP.Set(B2Vector3D(fitResult->getHelix().getDirection() * 1000));
 
  recTrack.fSign = fitResult->getChargeSign();
  TEveTrack* eveTrack = new TEveTrack(&recTrack, m_gftrackpropagator);
  eveTrack->SetName(label);
 
 
  if (track) {
    const genfit::AbsTrackRep* representation;
 
    if (m_drawCardinalRep) {
      representation = track->getCardinalRepresentation();
      B2DEBUG(100, "Draw cardinal rep");
    } else {
      const auto& representations = track->getRepresentations();
      if (representations.empty()) {
        B2ERROR("No representations found in the reco track!");
        return;
      }
      B2DEBUG(100, "Draw representation number 0.");
      representation = representations.front();
    }
 
    if (!track->hasTrackFitStatus(representation)) {
      B2ERROR("RecoTrack without FitStatus: will be skipped!");
      return;
    }
 
    const genfit::FitStatus* fitStatus = track->getTrackFitStatus(representation);
 
    isPruned = fitStatus->isTrackPruned();
 
    // GBL and Kalman cannot mix in a track.
    // What is 0 after first loop will stay 0:
    genfit::KalmanFitterInfo* fi = 0;
    genfit::KalmanFitterInfo* prevFi = 0;
    genfit::GblFitterInfo* gfi = 0;
    genfit::GblFitterInfo* prevGFi = 0;
    const genfit::MeasuredStateOnPlane* fittedState(NULL);
    const genfit::MeasuredStateOnPlane* prevFittedState(NULL);
 
 
    const auto& hitPoints = track->getHitPointsWithMeasurement();
    const unsigned int numpoints = hitPoints.size();
 
    int hitCounter = -1;
    for (genfit::TrackPoint* tp : hitPoints) { // loop over all points in the track
      hitCounter++;
 
      // get the fitter infos ------------------------------------------------------------------
      if (! tp->hasFitterInfo(representation)) {
        B2ERROR("trackPoint has no fitterInfo for rep");
        continue;
      }
 
      genfit::AbsFitterInfo* fitterInfo = tp->getFitterInfo(representation);
 
      fi = dynamic_cast<genfit::KalmanFitterInfo*>(fitterInfo);
      gfi = dynamic_cast<genfit::GblFitterInfo*>(fitterInfo);
 
      if (!gfi && !fi) {
        B2ERROR("Can only display KalmanFitterInfo or GblFitterInfo");
        continue;
      }
 
      if (gfi && fi)
        B2FATAL("AbsFitterInfo dynamic-casted to both KalmanFitterInfo and GblFitterInfo!");
 
 
      if (fi && ! tp->hasRawMeasurements()) {
        B2ERROR("trackPoint has no raw measurements");
        continue;
      }
 
      if (fi && ! fi->hasPredictionsAndUpdates()) {
        B2ERROR("KalmanFitterInfo does not have all predictions and updates");
        continue;
      }
 
      try {
        if (gfi)
          fittedState = &(gfi->getFittedState(true));
        if (fi)
          fittedState = &(fi->getFittedState(true));
      } catch (genfit::Exception& e) {
        B2ERROR(e.what() << " - can not get fitted state");
        continue;
      }
 
      ROOT::Math::XYZVector track_pos = ROOT::Math::XYZVector(representation->getPos(*fittedState));
 
      // draw track if corresponding option is set ------------------------------------------
      if (prevFittedState != NULL) {
 
        TEvePathMark::EType_e markType = TEvePathMark::kReference;
        if (hitCounter + 1 == static_cast<int>(numpoints)) //track should stop here.
          markType = TEvePathMark::kDecay;
 
        // Kalman: non-null prevFi ensures that the previous fitter info was also KalmanFitterInfo
        if (fi && prevFi) {
          makeLines(eveTrack, prevFittedState, fittedState, representation, markType, m_drawErrors);
          if (m_drawErrors) { // make sure to draw errors in both directions
            makeLines(eveTrack, prevFittedState, fittedState, representation, markType, m_drawErrors, 0);
          }
          //these are currently disabled.
          //TODO: if activated, I want to have a separate TEveStraightLineSet instead of eveTrack (different colors/options)
          if (m_drawForward)
            makeLines(eveTrack, prevFi->getForwardUpdate(), fi->getForwardPrediction(), representation, markType, m_drawErrors, 0);
          if (m_drawBackward)
            makeLines(eveTrack, prevFi->getBackwardPrediction(), fi->getBackwardUpdate(), representation, markType, m_drawErrors);
          // draw reference track if corresponding option is set ------------------------------------------
          if (m_drawRefTrack && fi->hasReferenceState() && prevFi->hasReferenceState())
            makeLines(eveTrack, prevFi->getReferenceState(), fi->getReferenceState(), representation, markType, false);
        }
 
        // GBL: non-null prevGFi ensures that the previous fitter info was also GblFitterInfo
        if (gfi && prevGFi) {
          makeLines(eveTrack, prevFittedState, fittedState, representation, markType, m_drawErrors);
          if (m_drawErrors) {
            makeLines(eveTrack, prevFittedState, fittedState, representation, markType, m_drawErrors, 0);
          }
 
          if (m_drawRefTrack && gfi->hasReferenceState() && prevGFi->hasReferenceState()) {
            genfit::StateOnPlane prevSop = prevGFi->getReferenceState();
            genfit::StateOnPlane sop = gfi->getReferenceState();
            makeLines(eveTrack, &prevSop, &sop, representation, markType, false);
          }
        }
 
      }
      prevFi = fi; // Kalman
      prevGFi = gfi; // GBL
      prevFittedState = fittedState;
 
 
      //loop over all measurements for this point (e.g. u and v-type strips)
      const int numMeasurements = tp->getNumRawMeasurements();
      for (int iMeasurement = 0; iMeasurement < numMeasurements; iMeasurement++) {
        const genfit::AbsMeasurement* m = tp->getRawMeasurement(iMeasurement);
 
        TVectorT<double> hit_coords;
        TMatrixTSym<double> hit_cov;
 
        if (fi) {
          // Kalman
          genfit::MeasurementOnPlane* mop = fi->getMeasurementOnPlane(iMeasurement);
          hit_coords.ResizeTo(mop->getState());
          hit_cov.ResizeTo(mop->getCov());
          hit_coords = mop->getState();
          hit_cov = mop->getCov();
        }
        if (gfi) {
          // GBL - has only one measurement (other should be already merged before the track is constructed)
          // That means tp->getNumRawMeasurements() returns 1 for tracks fitted by GBL, because GBLfit Module
          // merges all corresponding SVD strips to 2D combined clusters.
          genfit::MeasurementOnPlane gblMeas = gfi->getMeasurement();
          hit_coords.ResizeTo(gblMeas.getState());
          hit_cov.ResizeTo(gblMeas.getCov());
          hit_coords = gblMeas.getState();
          hit_cov = gblMeas.getCov();
        }
 
        // finished getting the hit infos -----------------------------------------------------
 
        // sort hit infos into variables ------------------------------------------------------
        ROOT::Math::XYZVector o = ROOT::Math::XYZVector(fittedState->getPlane()->getO());
        ROOT::Math::XYZVector u = ROOT::Math::XYZVector(fittedState->getPlane()->getU());
        ROOT::Math::XYZVector v = ROOT::Math::XYZVector(fittedState->getPlane()->getV());
 
        bool planar_hit = false;
        bool planar_pixel_hit = false;
        bool space_hit = false;
        bool wire_hit = false;
        bool wirepoint_hit = false;
        double_t hit_u = 0;
        double_t hit_v = 0;
        double_t plane_size = 4;
 
        int hit_coords_dim = m->getDim();
 
        if (dynamic_cast<const genfit::PlanarMeasurement*>(m) != NULL) {
          planar_hit = true;
          if (hit_coords_dim == 1) {
            hit_u = hit_coords(0);
          } else if (hit_coords_dim == 2) {
            planar_pixel_hit = true;
            hit_u = hit_coords(0);
            hit_v = hit_coords(1);
          }
        } else if (dynamic_cast<const genfit::SpacepointMeasurement*>(m) != NULL) {
          space_hit = true;
        } else if (dynamic_cast<const CDCRecoHit*>(m)
                   || dynamic_cast<const genfit::WireMeasurement*>(m)
                   || dynamic_cast<const genfit::WireMeasurementNew*>(m)) {
          wire_hit = true;
          hit_u = fabs(hit_coords(0));
          hit_v = v.Dot(track_pos - o); // move the covariance tube so that the track goes through it
          if (dynamic_cast<const genfit::WirePointMeasurement*>(m) != NULL) {
            wirepoint_hit = true;
            hit_v = hit_coords(1);
          }
        } else {
          B2ERROR("Hit " << hitCounter << ", Measurement " << iMeasurement << ": Unknown measurement type: skipping hit!");
          break;
        }
 
        // finished setting variables ---------------------------------------------------------
 
        // draw planes if corresponding option is set -----------------------------------------
        if (drawPlanes || (drawDetectors && planar_hit)) {
          ROOT::Math::XYZVector move(0, 0, 0);
          if (wire_hit) move = v * (v.Dot(track_pos - o)); // move the plane along the wire until the track goes through it
          TEveBox* box = boxCreator(o + move, u, v, plane_size, plane_size, 0.01);
          if (drawDetectors && planar_hit) {
            box->SetMainColor(kCyan);
          } else {
            box->SetMainColor(kGray);
          }
          box->SetMainTransparency(50);
          eveTrack->AddElement(box);
        }
        // finished drawing planes ------------------------------------------------------------
 
        // draw detectors if option is set, only important for wire hits ----------------------
        if (drawDetectors) {
 
          if (wire_hit) {
            TEveGeoShape* det_shape = new TEveGeoShape("det_shape");
            det_shape->SetShape(new TGeoTube(std::max(0., (double)(hit_u - 0.0105 / 2.)), hit_u + 0.0105 / 2., plane_size));
            fixGeoShapeRefCount(det_shape);
 
            ROOT::Math::XYZVector norm = u.Cross(v);
            TGeoRotation det_rot("det_rot", (u.Theta() * 180) / TMath::Pi(), (u.Phi() * 180) / TMath::Pi(),
                                 (norm.Theta() * 180) / TMath::Pi(), (norm.Phi() * 180) / TMath::Pi(),
                                 (v.Theta() * 180) / TMath::Pi(), (v.Phi() * 180) / TMath::Pi()); // move the tube to the right place and rotate it correctly
            ROOT::Math::XYZVector move = v * (v.Dot(track_pos - o)); // move the tube along the wire until the track goes through it
            TGeoCombiTrans det_trans(o.X() + move.X(),
                                     o.Y() + move.Y(),
                                     o.Z() + move.Z(),
                                     &det_rot);
            det_shape->SetTransMatrix(det_trans);
            det_shape->SetMainColor(kCyan);
            det_shape->SetMainTransparency(25);
            if ((drawHits && (hit_u + 0.0105 / 2 > 0)) || !drawHits) {
              eveTrack->AddElement(det_shape);
            }
          }
 
        }
        // finished drawing detectors ---------------------------------------------------------
 
        if (drawHits) {
 
          // draw planar hits, with distinction between strip and pixel hits ----------------
          if (planar_hit) {
            if (!planar_pixel_hit) {
              //strip hit
              static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
              const SVDRecoHit* recoHit = dynamic_cast<const SVDRecoHit*>(m);
              if (!recoHit) {
                B2WARNING("SVD recohit couldn't be converted... ");
                continue;
              }
 
              const VXD::SensorInfoBase& sensor = geo.getSensorInfo(recoHit->getSensorID());
              double du, dv;
              ROOT::Math::XYZVector a = o; //defines position of sensor plane
              double hit_res_u = hit_cov(0, 0);
              if (recoHit->isU()) {
                du = std::sqrt(hit_res_u);
                dv = sensor.getLength();
                a += hit_u * u;
              } else {
                du = sensor.getWidth();
                dv = std::sqrt(hit_res_u);
                a += hit_u * v;
              }
              double depth = sensor.getThickness();
              TEveBox* hit_box = boxCreator(a, u, v, du, dv, depth);
              hit_box->SetName("SVDRecoHit");
              hit_box->SetMainColor(c_recoHitColor);
              hit_box->SetMainTransparency(0);
              eveTrack->AddElement(hit_box);
            } else {
              //pixel hit
              // calculate eigenvalues to draw error-ellipse ----------------------------
              TMatrixDSymEigen eigen_values(hit_cov);
              TEveGeoShape* cov_shape = new TEveGeoShape("PXDRecoHit");
              const TVectorD& ev = eigen_values.GetEigenValues();
              const TMatrixD& eVec = eigen_values.GetEigenVectors();
              double pseudo_res_0 = m_errorScale * std::sqrt(ev(0));
              double pseudo_res_1 = m_errorScale * std::sqrt(ev(1));
              // finished calcluating, got the values -----------------------------------
 
              // calculate the semiaxis of the error ellipse ----------------------------
              cov_shape->SetShape(new TGeoEltu(pseudo_res_0, pseudo_res_1, 0.0105));
              fixGeoShapeRefCount(cov_shape);
              ROOT::Math::XYZVector pix_pos = o + hit_u * u + hit_v * v;
              ROOT::Math::XYZVector u_semiaxis = (pix_pos + eVec(0, 0) * u + eVec(1, 0) * v) - pix_pos;
              ROOT::Math::XYZVector v_semiaxis = (pix_pos + eVec(0, 1) * u + eVec(1, 1) * v) - pix_pos;
              ROOT::Math::XYZVector norm = u.Cross(v);
              // finished calculating ---------------------------------------------------
 
              // rotate and translate everything correctly ------------------------------
              TGeoRotation det_rot("det_rot", (u_semiaxis.Theta() * 180) / TMath::Pi(), (u_semiaxis.Phi() * 180) / TMath::Pi(),
                                   (v_semiaxis.Theta() * 180) / TMath::Pi(), (v_semiaxis.Phi() * 180) / TMath::Pi(),
                                   (norm.Theta() * 180) / TMath::Pi(), (norm.Phi() * 180) / TMath::Pi());
              TGeoCombiTrans det_trans(pix_pos.X(), pix_pos.Y(), pix_pos.Z(), &det_rot);
              cov_shape->SetTransMatrix(det_trans);
              // finished rotating and translating --------------------------------------
 
              cov_shape->SetMainColor(c_recoHitColor);
              cov_shape->SetMainTransparency(0);
              eveTrack->AddElement(cov_shape);
            }
          }
          // finished drawing planar hits ---------------------------------------------------
 
          // draw spacepoint hits -----------------------------------------------------------
          if (space_hit) {
 
            // get eigenvalues of covariance to know how to draw the ellipsoid ------------
            TMatrixDSymEigen eigen_values(m->getRawHitCov());
            TEveGeoShape* cov_shape = new TEveGeoShape("SpacePoint Hit");
            cov_shape->SetShape(new TGeoSphere(0., 1.));
            fixGeoShapeRefCount(cov_shape);
            const TVectorD& ev = eigen_values.GetEigenValues();
            const TMatrixD& eVec = eigen_values.GetEigenVectors();
            ROOT::Math::XYZVector eVec1(eVec(0, 0), eVec(1, 0), eVec(2, 0));
            ROOT::Math::XYZVector eVec2(eVec(0, 1), eVec(1, 1), eVec(2, 1));
            ROOT::Math::XYZVector eVec3(eVec(0, 2), eVec(1, 2), eVec(2, 2));
            // got everything we need -----------------------------------------------------
 
 
            TGeoRotation det_rot("det_rot", (eVec1.Theta() * 180) / TMath::Pi(), (eVec1.Phi() * 180) / TMath::Pi(),
                                 (eVec2.Theta() * 180) / TMath::Pi(), (eVec2.Phi() * 180) / TMath::Pi(),
                                 (eVec3.Theta() * 180) / TMath::Pi(), (eVec3.Phi() * 180) / TMath::Pi()); // the rotation is already clear
 
            // set the scaled eigenvalues -------------------------------------------------
            double pseudo_res_0 = m_errorScale * std::sqrt(ev(0));
            double pseudo_res_1 = m_errorScale * std::sqrt(ev(1));
            double pseudo_res_2 = m_errorScale * std::sqrt(ev(2));
            // finished scaling -----------------------------------------------------------
 
            // rotate and translate -------------------------------------------------------
            TGeoGenTrans det_trans(o.X(), o.Y(), o.Z(),
                                   //std::sqrt(pseudo_res_0/pseudo_res_1/pseudo_res_2), std::sqrt(pseudo_res_1/pseudo_res_0/pseudo_res_2), std::sqrt(pseudo_res_2/pseudo_res_0/pseudo_res_1), // this workaround is necessary due to the "normalization" performed in  TGeoGenTrans::SetScale
                                   //1/(pseudo_res_0),1/(pseudo_res_1),1/(pseudo_res_2),
                                   pseudo_res_0, pseudo_res_1, pseudo_res_2,
                                   &det_rot);
            cov_shape->SetTransMatrix(det_trans);
            // finished rotating and translating ------------------------------------------
 
            cov_shape->SetMainColor(c_recoHitColor);
            cov_shape->SetMainTransparency(10);
            eveTrack->AddElement(cov_shape);
          }
          // finished drawing spacepoint hits -----------------------------------------------
 
          // draw wire hits -----------------------------------------------------------------
          if (wire_hit) {
            const double cdcErrorScale = 1.0;
            TEveGeoShape* cov_shape = new TEveGeoShape("CDCRecoHit");
            double pseudo_res_0 = cdcErrorScale * std::sqrt(hit_cov(0, 0));
            double pseudo_res_1 = plane_size;
            if (wirepoint_hit) pseudo_res_1 = cdcErrorScale * std::sqrt(hit_cov(1, 1));
 
            cov_shape->SetShape(new TGeoTube(std::max(0., (double)(hit_u - pseudo_res_0)), hit_u + pseudo_res_0, pseudo_res_1));
            fixGeoShapeRefCount(cov_shape);
            ROOT::Math::XYZVector norm = u.Cross(v);
 
            // rotate and translate -------------------------------------------------------
            TGeoRotation det_rot("det_rot", (u.Theta() * 180) / TMath::Pi(), (u.Phi() * 180) / TMath::Pi(),
                                 (norm.Theta() * 180) / TMath::Pi(), (norm.Phi() * 180) / TMath::Pi(),
                                 (v.Theta() * 180) / TMath::Pi(), (v.Phi() * 180) / TMath::Pi());
            TGeoCombiTrans det_trans(o.X() + hit_v * v.X(),
                                     o.Y() + hit_v * v.Y(),
                                     o.Z() + hit_v * v.Z(),
                                     &det_rot);
            cov_shape->SetTransMatrix(det_trans);
            // finished rotating and translating ------------------------------------------
 
            cov_shape->SetMainColor(c_recoHitColor);
            cov_shape->SetMainTransparency(50);
            eveTrack->AddElement(cov_shape);
          }
          // finished drawing wire hits -----------------------------------------------------
        }
 
      }
    }
 
    auto& firstref = eveTrack->RefPathMarks().front();
    auto& lastref = eveTrack->RefPathMarks().back();
    double f = firstref.fV.Distance(recTrack.fV);
    double b = lastref.fV.Distance(recTrack.fV);
    if (f > 100 and f > b) {
      B2WARNING("Decay vertex is much closer to POCA than first vertex, reversing order of track points... (this is intended for cosmic tracks, if you see this message in other context it might indicate a problem)");
      //last ref is better than first...
      lastref.fType = TEvePathMarkD::kReference;
      firstref.fType = TEvePathMarkD::kDecay;
      std::reverse(eveTrack->RefPathMarks().begin(), eveTrack->RefPathMarks().end());
    }
  }
  eveTrack->SetTitle(TString::Format("%s\n"
                                     "pruned: %s\n"
                                     "pT=%.3f, pZ=%.3f\n"
                                     "pVal: %e",
                                     label.Data(),
                                     isPruned ? " yes" : "no",
                                     poca_momentum.Pt(), poca_momentum.Pz(),
                                     fitResult->getPValue()
                                    ));
  eveTrack->SetLineColor(c_trackColor);
  eveTrack->SetLineStyle(1);
  eveTrack->SetLineWidth(3.0);
 
 
  addToGroup("Fitted Tracks", eveTrack);
  if (track)
    addObject(track, eveTrack);
  addObject(belle2Track, eveTrack);
}

addTrackCandidate()

void addTrackCandidate	(	const std::string &	collectionName,
		const RecoTrack &	recoTrack
	)

Add a RecoTrack, to evaluate track finding.

Definition at line 202 of file EVEVisualization.cc.

{
  const TString label = ObjectInfo::getIdentifier(&recoTrack);
  // parse the option string ------------------------------------------------------------------------
  bool drawHits = false;
 
  if (m_options != "") {
    for (size_t i = 0; i < m_options.length(); i++) {
      if (m_options.at(i) == 'H') drawHits = true;
    }
  }
  // finished parsing the option string -------------------------------------------------------------
 
 
  //track seeds
  const B2Vector3D& track_pos = recoTrack.getPositionSeed();
  const B2Vector3D& track_mom = recoTrack.getMomentumSeed();
 
  TEveStraightLineSet* lines = new TEveStraightLineSet("RecoHits for " + label);
  lines->SetMainColor(c_recoTrackColor);
  lines->SetMarkerColor(c_recoTrackColor);
  lines->SetMarkerStyle(6);
  lines->SetMainTransparency(60);
 
  if (drawHits) {
    // Loop over all hits in the track (three different types)
    for (const RecoHitInformation::UsedPXDHit* pxdHit : recoTrack.getPXDHitList()) {
      addRecoHit(pxdHit, lines);
    }
 
    for (const RecoHitInformation::UsedSVDHit* svdHit : recoTrack.getSVDHitList()) {
      addRecoHit(svdHit, lines);
    }
 
    for (const RecoHitInformation::UsedCDCHit* cdcHit : recoTrack.getCDCHitList()) {
      addRecoHit(cdcHit, lines);
    }
  }
 
  TEveRecTrack rectrack;
  rectrack.fP.Set(track_mom);
  rectrack.fV.Set(track_pos);
 
  TEveTrack* track_lines = new TEveTrack(&rectrack, m_gftrackpropagator);
  track_lines->SetName(label); //popup label set at end of function
  track_lines->SetPropagator(m_gftrackpropagator);
  track_lines->SetLineColor(c_recoTrackColor);
  track_lines->SetLineWidth(1);
  track_lines->SetTitle(ObjectInfo::getTitle(&recoTrack));
 
  track_lines->SetCharge((int)recoTrack.getChargeSeed());
 
 
  track_lines->AddElement(lines);
  addToGroup(collectionName, track_lines);
  addObject(&recoTrack, track_lines);
}

addTrackCandidateImproved()

void addTrackCandidateImproved	(	const std::string &	collectionName,
		const RecoTrack &	recoTrack
	)

Add a RecoTrack, but use stored genfit track representation to make visualisation objects.

FIXME this is mostly just a workaround for monopoles.

Definition at line 261 of file EVEVisualization.cc.

{
  const TString label = ObjectInfo::getIdentifier(&recoTrack);
  // parse the option string ------------------------------------------------------------------------
  bool drawHits = false;
 
  if (m_options != "") {
    for (size_t i = 0; i < m_options.length(); i++) {
      if (m_options.at(i) == 'H') drawHits = true;
    }
  }
  // finished parsing the option string -------------------------------------------------------------
 
  // Create a track as a polyline through reconstructed points
  // FIXME this is snatched from PrimitivePlotter, need to add extrapolation out of CDC
  TEveLine* track = new TEveLine(); // We are going to just add points with SetNextPoint
  std::vector<ROOT::Math::XYZVector> posPoints; // But first we'll have to sort them as in RecoHits axial and stereo come in blocks
  track->SetName(label); //popup label set at end of function
  track->SetLineColor(c_recoTrackColor);
  track->SetLineWidth(3);
  track->SetTitle(ObjectInfo::getTitle(&recoTrack));
  track->SetSmooth(true);
 
  for (auto recoHit : recoTrack.getRecoHitInformations()) {
    // skip for reco hits which have not been used in the fit (and therefore have no fitted information on the plane
    if (!recoHit->useInFit())
      continue;
 
    // Need TVector3 here for genfit interface below
    TVector3 pos;
    TVector3 mom;
    TMatrixDSym cov;
 
    try {
      const auto* trackPoint = recoTrack.getCreatedTrackPoint(recoHit);
      const auto* fittedResult = trackPoint->getFitterInfo();
      if (not fittedResult) {
        B2WARNING("Skipping unfitted track point");
        continue;
      }
      const genfit::MeasuredStateOnPlane& state = fittedResult->getFittedState();
      state.getPosMomCov(pos, mom, cov);
    } catch (const genfit::Exception&) {
      B2WARNING("Skipping state with strange pos, mom or cov");
      continue;
    }
 
    posPoints.push_back(ROOT::Math::XYZVector(pos.X(), pos.Y(), pos.Z()));
  }
 
  sort(posPoints.begin(), posPoints.end(),
  [](const ROOT::Math::XYZVector & a, const ROOT::Math::XYZVector & b) -> bool {
    return a.X() * a.X() + a.Y() * a.Y() > b.X() * b.X() + b.Y() * b.Y();
  });
  for (auto vec : posPoints) {
    track->SetNextPoint(vec.X(), vec.Y(), vec.Z());
  }
  // add corresponding hits     ---------------------------------------------------------------------
  TEveStraightLineSet* lines = new TEveStraightLineSet("RecoHits for " + label);
  lines->SetMainColor(c_recoTrackColor);
  lines->SetMarkerColor(c_recoTrackColor);
  lines->SetMarkerStyle(6);
  lines->SetMainTransparency(60);
 
  if (drawHits) {
    // Loop over all hits in the track (three different types)
    for (const RecoHitInformation::UsedPXDHit* pxdHit : recoTrack.getPXDHitList()) {
      addRecoHit(pxdHit, lines);
    }
 
    for (const RecoHitInformation::UsedSVDHit* svdHit : recoTrack.getSVDHitList()) {
      addRecoHit(svdHit, lines);
    }
 
    for (const RecoHitInformation::UsedCDCHit* cdcHit : recoTrack.getCDCHitList()) {
      addRecoHit(cdcHit, lines);
    }
  }
 
  track->AddElement(lines);
  addToGroup(collectionName, track);
  addObject(&recoTrack, track);
}

addUnassignedRecoHits()

void addUnassignedRecoHits ( const StoreArray< T > &  hits )

inline

After adding recohits for tracks/candidates, this function adds the remaining hits in a global collection.

Definition at line 190 of file EVEVisualization.h.

    {
      if (hits.getEntries() == 0)
        return;
      if (!m_unassignedRecoHits) {
        m_unassignedRecoHits = new TEveStraightLineSet("Unassigned RecoHits");
        m_unassignedRecoHits->SetTitle("Unassigned RecoHits");
        m_unassignedRecoHits->SetMainColor(c_unassignedHitColor);
        m_unassignedRecoHits->SetMarkerColor(c_unassignedHitColor);
        m_unassignedRecoHits->SetMarkerStyle(6);
        //m_unassignedRecoHits->SetMainTransparency(60);
      }
      for (const T& hit : hits) {
        if (m_shownRecohits.count(&hit) == 0) {
          addRecoHit(&hit, m_unassignedRecoHits);
        }
      }
    }

addVertex()

void addVertex

(

const genfit::GFRaveVertex *

vertex

)

Add a vertex point and its covariance matrix.

Definition at line 1351 of file EVEVisualization.cc.

{
  ROOT::Math::XYZVector v = ROOT::Math::XYZVector(vertex->getPos());
  TEvePointSet* vertexPoint = new TEvePointSet(ObjectInfo::getInfo(vertex));
  //sadly, setting a title for a TEveGeoShape doesn't result in a popup...
  vertexPoint->SetTitle(ObjectInfo::getTitle(vertex));
  vertexPoint->SetMainColor(c_recoHitColor);
  vertexPoint->SetNextPoint(v.X(), v.Y(), v.Z());
 
  TMatrixDSymEigen eigen_values(vertex->getCov());
  TEveGeoShape* det_shape = new TEveGeoShape(ObjectInfo::getInfo(vertex) + " Error");
  det_shape->SetShape(new TGeoSphere(0., 1.));   //Initially created as a sphere, then "scaled" into an ellipsoid.
  fixGeoShapeRefCount(det_shape);
  const TVectorD& ev = eigen_values.GetEigenValues(); //Assigns the eigenvalues into the "ev" matrix.
  const TMatrixD& eVec = eigen_values.GetEigenVectors();  //Assigns the eigenvalues into the "eVec" matrix.
  //Define the 3 eigenvectors of the covariance matrix as objects of the ROOT::Math::XYZVector class using constructor.
  ROOT::Math::XYZVector eVec1(eVec(0, 0), eVec(1, 0), eVec(2, 0));
  //eVec(i,j) uses the method/overloaded operator ( . ) of the TMatrixT class to return the matrix entry.
  ROOT::Math::XYZVector eVec2(eVec(0, 1), eVec(1, 1), eVec(2, 1));
  ROOT::Math::XYZVector eVec3(eVec(0, 2), eVec(1, 2), eVec(2, 2));
  // got everything we need -----------------------------------------------------   //Eigenvalues(semi axis) of the covariance matrix accquired!
 
 
  TGeoRotation det_rot("det_rot", (eVec1.Theta() * 180) / TMath::Pi(), (eVec1.Phi() * 180) / TMath::Pi(),
                       (eVec2.Theta() * 180) / TMath::Pi(), (eVec2.Phi() * 180) / TMath::Pi(),
                       (eVec3.Theta() * 180) / TMath::Pi(), (eVec3.Phi() * 180) / TMath::Pi()); // the rotation is already clear
 
  // set the scaled eigenvalues -------------------------------------------------
  //"Scaled" eigenvalues pseudo_res (lengths of the semi axis) are the sqrt of the eigenvalues.
  double pseudo_res_0 = std::sqrt(ev(0));
  double pseudo_res_1 = std::sqrt(ev(1));
  double pseudo_res_2 = std::sqrt(ev(2));
 
  //B2INFO("The pseudo_res_0/1/2 are " << pseudo_res_0 << "," << pseudo_res_1 << "," << pseudo_res_2); //shows the scaled eigenvalues
 
 
 
  // rotate and translate -------------------------------------------------------
  TGeoGenTrans det_trans(v.X(), v.Y(), v.Z(), pseudo_res_0, pseudo_res_1, pseudo_res_2,
                         &det_rot); //Puts the ellipsoid at the position of the vertex, v(0)=v.X(), operator () overloaded.
  det_shape->SetTransMatrix(det_trans);
  // finished rotating and translating ------------------------------------------
 
  det_shape->SetMainColor(kOrange);   //The color of the error ellipsoid.
  det_shape->SetMainTransparency(0);
 
  vertexPoint->AddElement(det_shape);
  addToGroup("Vertices", vertexPoint);
  addObject(vertex, vertexPoint);
}

boxCreator()

TEveBox * boxCreator ( const ROOT::Math::XYZVector &  o, ROOT::Math::XYZVector  u, ROOT::Math::XYZVector  v, float  ud, float  vd, float  depth  )

private

Create a box around o, oriented along u and v with widths ud, vd and depth and return a pointer to the box object.

Definition at line 849 of file EVEVisualization.cc.

{
  //force minimum width of polygon to deal with Eve limits
  float min = 0.04;
  if (vd < min)
    vd = min;
  if (ud < min)
    ud = min;
  if (depth < min)
    depth = min;
 
  TEveBox* box = new TEveBox;
  box->SetPickable(true);
 
  ROOT::Math::XYZVector norm = u.Cross(v);
  u *= (0.5 * ud);
  v *= (0.5 * vd);
  norm *= (0.5 * depth);
 
 
  for (int k = 0; k < 8; ++k) {
    // Coordinates for all eight corners of the box
    // as two parallel rectangles, with vertices specified in clockwise direction
    int signU = ((k + 1) & 2) ? -1 : 1;
    int signV = (k & 4) ? -1 : 1;
    int signN = (k & 2) ? -1 : 1;
    float vertex[3];
    // for (int i = 0; i < 3; ++i) {
    //   vertex[i] = o(i) + signU * u(i) + signV * v(i) + signN * norm(i);
    // }
    vertex[0] = o.X() + signU * u.X() + signV * v.X() + signN * norm.X();
    vertex[1] = o.Y() + signU * u.Y() + signV * v.Y() + signN * norm.Y();
    vertex[2] = o.Z() + signU * u.Z() + signV * v.Z() + signN * norm.Z();
    box->SetVertex(k, vertex);
  }
 
  return box;
}

clearEvent()

void clearEvent

(

)

clear event data.

Definition at line 1308 of file EVEVisualization.cc.

{
  if (!gEve)
    return;
 
  VisualRepMap::getInstance()->clear();
  for (auto& groupPair : m_groups) {
    //store visibility, invalidate pointers
    if (groupPair.second.group)
      groupPair.second.visible = groupPair.second.group->GetRnrState();
    groupPair.second.group = nullptr;
  }
 
  m_mcparticleTracks.clear();
  m_shownRecohits.clear();
  m_tracklist->DestroyElements();
 
  //remove ECL data from event
  m_calo3d->SetData(NULL);
  m_calo3d->DestroyElements();
 
  //lower energy threshold for ECL
  float ecl_threshold = 0.01;
  if (m_eclData)
    ecl_threshold = m_eclData->GetSliceThreshold(0);
 
  destroyEveElement(m_eclData);
  m_eclData = new TEveCaloDataVec(1); //#slices
  m_eclData->IncDenyDestroy();
  m_eclData->RefSliceInfo(0).Setup("ECL", ecl_threshold, kRed);
 
  if (m_unassignedRecoHits)
    m_unassignedRecoHitsVisibility = m_unassignedRecoHits->GetRnrState();
  destroyEveElement(m_unassignedRecoHits);
 
  gEve->GetSelection()->RemoveElements();
  gEve->GetHighlight()->RemoveElements();
  //other things are cleaned up by TEve...
}

makeLines()

void makeLines ( TEveTrack *  eveTrack, const genfit::StateOnPlane *  prevState, const genfit::StateOnPlane *  state, const genfit::AbsTrackRep *  rep, TEvePathMark::EType_e  markType, bool  drawErrors, int  markerPos = 1  )

private

Create hit visualisation for the given options, and add them to 'eveTrack'.

Definition at line 889 of file EVEVisualization.cc.

{
  using namespace genfit;
 
  // Need TVector3 for genfit interface
  TVector3 pos, dir, oldPos, oldDir;
  rep->getPosDir(*state, pos, dir);
  rep->getPosDir(*prevState, oldPos, oldDir);
 
  double distA = (pos - oldPos).Mag();
  double distB = distA;
  if ((pos - oldPos)*oldDir < 0)
    distA *= -1.;
  if ((pos - oldPos)*dir < 0)
    distB *= -1.;
 
  TEvePathMark mark(
    markType,
    TEveVector(pos.X(), pos.Y(), pos.Z()),
    TEveVector(dir.X(), dir.Y(), dir.Z())
  );
  eveTrack->AddPathMark(mark);
 
 
  if (drawErrors) {
    const MeasuredStateOnPlane* measuredState;
    if (markerPos == 0)
      measuredState = dynamic_cast<const MeasuredStateOnPlane*>(prevState);
    else
      measuredState = dynamic_cast<const MeasuredStateOnPlane*>(state);
 
    if (measuredState != NULL) {
 
      // step for evaluate at a distance from the original plane
      ROOT::Math::XYZVector eval;
      if (markerPos == 0)
        eval = 0.2 * distA * oldDir;
      else
        eval = -0.2 * distB * dir;
 
 
      // get cov at first plane
      TMatrixDSym cov;
      // Need TVector3 for genfit interface
      TVector3 position, direction;
      rep->getPosMomCov(*measuredState, position, direction, cov);
 
      // get eigenvalues & -vectors
      TMatrixDSymEigen eigen_values(cov.GetSub(0, 2, 0, 2));
      const TVectorD& ev = eigen_values.GetEigenValues();
      const TMatrixD& eVec = eigen_values.GetEigenVectors();
      ROOT::Math::XYZVector eVec1, eVec2;
      // limit
      static const double maxErr = 1000.;
      double ev0 = std::min(ev(0), maxErr);
      double ev1 = std::min(ev(1), maxErr);
      double ev2 = std::min(ev(2), maxErr);
 
      // get two largest eigenvalues/-vectors
      if (ev0 < ev1 && ev0 < ev2) {
        eVec1.SetXYZ(eVec(0, 1), eVec(1, 1), eVec(2, 1));
        eVec1 *= sqrt(ev1);
        eVec2.SetXYZ(eVec(0, 2), eVec(1, 2), eVec(2, 2));
        eVec2 *= sqrt(ev2);
      } else if (ev1 < ev0 && ev1 < ev2) {
        eVec1.SetXYZ(eVec(0, 0), eVec(1, 0), eVec(2, 0));
        eVec1 *= sqrt(ev0);
        eVec2.SetXYZ(eVec(0, 2), eVec(1, 2), eVec(2, 2));
        eVec2 *= sqrt(ev2);
      } else {
        eVec1.SetXYZ(eVec(0, 0), eVec(1, 0), eVec(2, 0));
        eVec1 *= sqrt(ev0);
        eVec2.SetXYZ(eVec(0, 1), eVec(1, 1), eVec(2, 1));
        eVec2 *= sqrt(ev1);
      }
 
      if (eVec1.Cross(eVec2).Dot(eval) < 0)
        eVec2 *= -1;
      //assert(eVec1.Cross(eVec2)*eval > 0);
 
      ROOT::Math::XYZVector oldEVec1(eVec1);
 
      const int nEdges = 24;
      std::vector<ROOT::Math::XYZVector> vertices;
 
      vertices.push_back(ROOT::Math::XYZVector(position));
 
      // vertices at plane
      for (int i = 0; i < nEdges; ++i) {
        const double angle = 2 * TMath::Pi() / nEdges * i;
        vertices.push_back(ROOT::Math::XYZVector(position) + cos(angle)*eVec1 + sin(angle)*eVec2);
      }
 
 
 
      SharedPlanePtr newPlane(new DetPlane(*(measuredState->getPlane())));
      newPlane->setO(position + XYZToTVector(eval));
 
      MeasuredStateOnPlane stateCopy(*measuredState);
      try {
        rep->extrapolateToPlane(stateCopy, newPlane);
      } catch (Exception& e) {
        B2ERROR(e.what());
        return;
      }
 
      // get cov at 2nd plane
      rep->getPosMomCov(stateCopy, position, direction, cov);
 
      // get eigenvalues & -vectors
      {
        TMatrixDSymEigen eigen_values2(cov.GetSub(0, 2, 0, 2));
        const TVectorD& eVal = eigen_values2.GetEigenValues();
        const TMatrixD& eVect = eigen_values2.GetEigenVectors();
        // limit
        ev0 = std::min(eVal(0), maxErr);
        ev1 = std::min(eVal(1), maxErr);
        ev2 = std::min(eVal(2), maxErr);
 
        // get two largest eigenvalues/-vectors
        if (ev0 < ev1 && ev0 < ev2) {
          eVec1.SetXYZ(eVect(0, 1), eVect(1, 1), eVect(2, 1));
          eVec1 *= sqrt(ev1);
          eVec2.SetXYZ(eVect(0, 2), eVect(1, 2), eVect(2, 2));
          eVec2 *= sqrt(ev2);
        } else if (ev1 < ev0 && ev1 < ev2) {
          eVec1.SetXYZ(eVect(0, 0), eVect(1, 0), eVect(2, 0));
          eVec1 *= sqrt(ev0);
          eVec2.SetXYZ(eVect(0, 2), eVect(1, 2), eVect(2, 2));
          eVec2 *= sqrt(ev2);
        } else {
          eVec1.SetXYZ(eVect(0, 0), eVect(1, 0), eVect(2, 0));
          eVec1 *= sqrt(ev0);
          eVec2.SetXYZ(eVect(0, 1), eVect(1, 1), eVect(2, 1));
        } eVec2 *= sqrt(ev1);
      }
 
      if (eVec1.Cross(eVec2).Dot(eval) < 0)
        eVec2 *= -1;
      //assert(eVec1.Cross(eVec2)*eval > 0);
 
      if (oldEVec1.Dot(eVec1) < 0) {
        eVec1 *= -1;
        eVec2 *= -1;
      }
 
      // vertices at 2nd plane
      double angle0 = ROOT::Math::VectorUtil::Angle(eVec1, oldEVec1);
      if (eVec1.Dot(eval.Cross(oldEVec1)) < 0)
        angle0 *= -1;
      for (int i = 0; i < nEdges; ++i) {
        const double angle = 2 * TMath::Pi() / nEdges * i - angle0;
        vertices.push_back(ROOT::Math::XYZVector(position) + cos(angle)*eVec1 + sin(angle)*eVec2);
      }
 
      vertices.push_back(ROOT::Math::XYZVector(position));
 
 
      TEveTriangleSet* error_shape = new TEveTriangleSet(vertices.size(), nEdges * 2);
      for (unsigned int k = 0; k < vertices.size(); ++k) {
        error_shape->SetVertex(k, vertices[k].X(), vertices[k].Y(), vertices[k].Z());
      }
 
      assert(vertices.size() == 2 * nEdges + 2);
 
      int iTri(0);
      for (int i = 0; i < nEdges; ++i) {
        //error_shape->SetTriangle(iTri++,  0,             i+1,        (i+1)%nEdges+1);
        error_shape->SetTriangle(iTri++,  i + 1,           i + 1 + nEdges, (i + 1) % nEdges + 1);
        error_shape->SetTriangle(iTri++, (i + 1) % nEdges + 1, i + 1 + nEdges, (i + 1) % nEdges + 1 + nEdges);
        //error_shape->SetTriangle(iTri++,  2*nEdges+1,    i+1+nEdges, (i+1)%nEdges+1+nEdges);
      }
 
      //assert(iTri == nEdges*4);
 
      error_shape->SetMainColor(c_trackColor);
      error_shape->SetMainTransparency(25);
      eveTrack->AddElement(error_shape);
    }
  }
}

makeTracks()

void makeTracks

(

)

Create visual representation of all tracks.

Needs to be called after all hits / tracks are added.

Definition at line 1249 of file EVEVisualization.cc.

{
  for (auto& mcTrackPair : m_mcparticleTracks) {
    MCTrack& mcTrack = mcTrackPair.second;
    if (mcTrack.track) {
      if (mcTrack.simhits->Size() > 0) {
        mcTrack.track->AddElement(mcTrack.simhits);
      } else {
        //if we don't add it, remove empty collection
        destroyEveElement(mcTrack.simhits);
      }
 
      TEveElement* parent = m_tracklist;
      if (mcTrack.parentParticle) {
        const auto& parentIt = m_mcparticleTracks.find(mcTrack.parentParticle);
        if (parentIt != m_mcparticleTracks.end()) {
          parent = parentIt->second.track;
        }
      }
      parent->AddElement(mcTrack.track);
    } else { //add simhits directly
      gEve->AddElement(mcTrack.simhits);
    }
  }
  gEve->AddElement(m_tracklist);
  m_tracklist->MakeTracks();
  m_tracklist->SelectByP(c_minPCut, FLT_MAX); //don't show too many particles by default...
 
  for (size_t i = 0; i < m_options.length(); i++) {
    if (m_options.at(i) == 'M') {
      m_gftrackpropagator->SetRnrDaughters(true);
      m_gftrackpropagator->SetRnrReferences(true);
      //m_gftrackpropagator->SetRnrFV(true); //TODO: this crashes?
      TMarker m;
      m.SetMarkerColor(c_trackMarkerColor);
      m.SetMarkerStyle(1); //a single pixel
      m.SetMarkerSize(1); //ignored.
      m_gftrackpropagator->RefPMAtt() = m;
      m_gftrackpropagator->RefFVAtt() = m;
    }
  }
 
  m_consttrackpropagator->SetMagField(0, 0, -1.5);
 
  m_eclData->DataChanged(); //update limits (Empty() won't work otherwise)
  if (!m_eclData->Empty()) {
    m_eclData->SetAxisFromBins(0.0,
                               0.0); //epsilon_x/y = 0 so we don't merge neighboring bins. This avoids some rendering issues with projections of small clusters.
    m_calo3d->SetData(m_eclData);
  }
  gEve->AddElement(m_calo3d);
 
  if (m_unassignedRecoHits) {
    m_unassignedRecoHits->SetRnrState(m_unassignedRecoHitsVisibility);
    gEve->AddElement(m_unassignedRecoHits);
  }
 
}

setAssignToPrimaries()

void setAssignToPrimaries ( bool  on )

inline

If true, hits created by secondary particles (e.g.

delta electrons) will be assigned to the original primary particle.

Definition at line 267 of file EVEVisualization.h.

{ m_assignToPrimaries = on; }

setErrScale()

void setErrScale

(

double

errScale = 1.

)

Set the scaling factor for the visualization of track hit errors.

(only affects PXD and SpacePoint hits, which are somewhat small

Definition at line 184 of file EVEVisualization.cc.

{ m_errorScale = errScale; }

setHideSecondaries()

void setHideSecondaries ( bool  on )

inline

If true, secondary MCParticles (and hits created by them) will not be shown.

Definition at line 270 of file EVEVisualization.h.

{ m_hideSecondaries = on; }

setOptions()

void setOptions

(

const std::string &

opts

)

Set the display options.

The option string lets you steer the way the events are displayed. The following options are available:

'D': Draw detectors. This causes a simple representation for all detectors to be drawn. For planar detectors, this is a plane with the same position and orientation of the real detector plane, but with different size. For wires, this is a tube whose diameter is equal to the value measured by the wire. Spacepoint hits are not affected by this option.

'H': Draw hits. This causes the hits to be visualized. Normally, the size of the hit representation is connected to the covariance matrix of the hit, scaled by the value set in setErrScale which is normally 1. Normally used in connection with 'D'.

'M': Draw track markers. Draw the intersection points between the track and the virtual (and/or real) detector planes. 'P': Draw detector planes. Draws the virtual (and/or real) detector planes.

Definition at line 182 of file EVEVisualization.cc.

{ m_options = opts; }

showUserData()

void showUserData

(

const DisplayData &

displayData

)

Add user-defined data (labels, points, etc.)

Definition at line 1843 of file EVEVisualization.cc.

{
  for (const auto& labelPair : displayData.m_labels) {
    TEveText* text = new TEveText(labelPair.first.c_str());
    text->SetName(labelPair.first.c_str());
    text->SetTitle(labelPair.first.c_str());
    text->SetMainColor(kGray + 1);
    const ROOT::Math::XYZVector& p = labelPair.second;
    text->PtrMainTrans()->SetPos(p.X(), p.Y(), p.Z());
    addToGroup("DisplayData", text);
  }
 
  for (const auto& pointPair : displayData.m_pointSets) {
    TEvePointSet* points = new TEvePointSet(pointPair.first.c_str());
    points->SetTitle(pointPair.first.c_str());
    points->SetMarkerStyle(7);
    points->SetMainColor(kGreen);
    for (const auto& p : pointPair.second) {
      points->SetNextPoint(p.X(), p.Y(), p.Z());
    }
    addToGroup("DisplayData", points);
  }
 
  int randomColor = 2; //primary colours, changing rapidly with index
  for (const auto& arrow : displayData.m_arrows) {
    const ROOT::Math::XYZVector pos = arrow.start;
    const ROOT::Math::XYZVector dir = arrow.end - pos;
    TEveArrow* eveArrow = new TEveArrow(dir.X(), dir.Y(), dir.Z(), pos.X(), pos.Y(), pos.Z());
    eveArrow->SetName(arrow.name.c_str());
    eveArrow->SetTitle(arrow.name.c_str());
    int arrowColor = arrow.color;
    if (arrowColor == -1) {
      arrowColor = randomColor;
      randomColor++;
    }
    eveArrow->SetMainColor(arrowColor);
 
    //add label
    TEveText* text = new TEveText(arrow.name.c_str());
    text->SetMainColor(arrowColor);
    //place label in middle of arrow, with some slight offset
    // orthogonal direction is arbitrary, set smallest component zero
    ROOT::Math::XYZVector orthogonalDir;
    if (std::abs(dir.X()) < std::abs(dir.Y())) {
      if (std::abs(dir.X()) < std::abs(dir.Z())) {
        orthogonalDir.SetCoordinates(0, dir.Z(), -dir.Y());
      } else {
        orthogonalDir.SetCoordinates(dir.Y(), -dir.X(), 0);
      }
    } else {
      if (std::abs(dir.Y()) < std::abs(dir.Z())) {
        orthogonalDir.SetCoordinates(-dir.Z(), 0, dir.X());
      } else {
        orthogonalDir.SetCoordinates(dir.Y(), -dir.X(), 0);
      }
    }
    const ROOT::Math::XYZVector& labelPos = pos + 0.5 * dir + 0.1 * orthogonalDir;
    text->PtrMainTrans()->SetPos(labelPos.X(), labelPos.Y(), labelPos.Z());
    eveArrow->AddElement(text);
    addToGroup("DisplayData", eveArrow);
  }
 
}

Member Data Documentation

c_klmClusterColor

const int c_klmClusterColor = getTColorID("Chameleon", 1)

staticprivate

Color for KLMCluster objects.

Definition at line 99 of file EVEVisualization.h.

c_minPCut

constexpr double c_minPCut = 0.00

staticconstexprprivate

don't show MCParticles with momentum below this cutoff.

Definition at line 363 of file EVEVisualization.h.

c_recoHitColor

const int c_recoHitColor = getTColorID("Orange", 1)

staticprivate

Color for reco hits.

Definition at line 89 of file EVEVisualization.h.

c_recoTrackColor

const int c_recoTrackColor = getTColorID("Sky Blue", 1)

staticprivate

Color for TrackCandidates.

Definition at line 91 of file EVEVisualization.h.

c_trackColor

const int c_trackColor = getTColorID("Sky Blue", 2)

staticprivate

Color for tracks.

Definition at line 93 of file EVEVisualization.h.

c_trackMarkerColor

const int c_trackMarkerColor = getTColorID("Chameleon", 3)

staticprivate

Color for track markers.

Definition at line 95 of file EVEVisualization.h.

c_unassignedHitColor

const int c_unassignedHitColor = getTColorID("Plum", 1)

staticprivate

Color for unassigned (reco)hits.

Definition at line 97 of file EVEVisualization.h.

m_assignToPrimaries

bool m_assignToPrimaries

private

If true, hits created by secondary particles (e.g.

delta electrons) will be assigned to the original primary particle.

Definition at line 325 of file EVEVisualization.h.

m_bfield

EveVisBField* m_bfield

private

The global magnetic field.

Definition at line 352 of file EVEVisualization.h.

m_calo3d

TEveCalo3D* m_calo3d

private

Object for the energy bar visualisation.

Definition at line 275 of file EVEVisualization.h.

m_consttrackpropagator

TEveTrackPropagator* m_consttrackpropagator

private

Track propagator for CDCTriggerTracks (uses constant B field)

Definition at line 346 of file EVEVisualization.h.

m_drawBackward

bool m_drawBackward = false

private

draw backward in addTrack

Definition at line 378 of file EVEVisualization.h.

m_drawCardinalRep

bool m_drawCardinalRep = true

private

Draw cardinal representation in addTrack.

Definition at line 366 of file EVEVisualization.h.

m_drawErrors

bool m_drawErrors = false

private

Draw errors in addTrack.

Definition at line 369 of file EVEVisualization.h.

m_drawForward

bool m_drawForward = false

private

draw forward in addTrack

Definition at line 375 of file EVEVisualization.h.

m_drawRefTrack

bool m_drawRefTrack = false

private

Draw reference track in addTrack.

Definition at line 372 of file EVEVisualization.h.

m_eclData

TEveCaloDataVec* m_eclData

private

ECL cluster data.

Definition at line 349 of file EVEVisualization.h.

m_errorScale

double m_errorScale

private

Rescale PXD/SVD errors with this factor to ensure visibility.

Definition at line 316 of file EVEVisualization.h.

m_gftrackpropagator

TEveTrackPropagator* m_gftrackpropagator

private

Track propagator for genfit::Tracks (different mainly because of drawing options)

Definition at line 343 of file EVEVisualization.h.

m_groups

std::map<std::string, ElementGroup> m_groups

private

name -> grouping element.

Definition at line 334 of file EVEVisualization.h.

m_hideSecondaries

bool m_hideSecondaries {false}

private

If true, secondary MCParticles (and hits created by them) will not be shown.

Definition at line 328 of file EVEVisualization.h.

m_mcparticleTracks

std::map<const MCParticle*, MCTrack> m_mcparticleTracks

private

map MCParticles to MCTrack (so hits can be added to the correct track).

Definition at line 331 of file EVEVisualization.h.

m_options

std::string m_options

private

Option string for genfit::Track visualisation.

See also

setOptions

Definition at line 322 of file EVEVisualization.h.

m_shownRecohits

std::set<const TObject*> m_shownRecohits

private

List of shown recohits (PXDCluster, SVDCluster, CDCHit).

Definition at line 355 of file EVEVisualization.h.

m_tracklist

TEveTrackList* m_tracklist

private

parent object for MC tracks.

Definition at line 337 of file EVEVisualization.h.

m_trackpropagator

TEveTrackPropagator* m_trackpropagator

private

Track propagator for MCParticles.

Definition at line 340 of file EVEVisualization.h.

m_unassignedRecoHits

TEveStraightLineSet* m_unassignedRecoHits = nullptr

private

Unassigned recohits.

Definition at line 358 of file EVEVisualization.h.

m_unassignedRecoHitsVisibility

bool m_unassignedRecoHitsVisibility = true

private

is m_unassignedRecoHits visible?

Definition at line 360 of file EVEVisualization.h.

---

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

• display/include/EVEVisualization.h
• display/src/EVEVisualization.cc