TrackHandleBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 

//                                                            //
//  Header file for class TrackHandleBase                     //
//                                                            //
//  Description: Base class for track handles.                //
//                                                            //
//  Author: Thomas H. Kittelmann (Thomas.Kittelmann@cern.ch)  //
//  Initial version: February 2008                            //
//                                                            //
 
#ifndef TRACKHANDLEBASE_H
#define TRACKHANDLEBASE_H
 
#include "VP1TrackSystems/TrackCommonFlags.h"
 
#include "TrkEventPrimitives/ParticleHypothesis.h"
 
// GeoModel
#include "GeoPrimitives/GeoPrimitives.h"
//
#include "GeoModelKernel/GeoVPhysVol.h"
 
#include <QStringList>
#include <QTreeWidgetItem>
#include <memory>
#include <vector>
#include <set>
#include <optional>
#include <QList>
#include <QFlags>
 
 
class AssocObjAttachmentHandle;
class AssociatedObjectHandleBase;
class TrackCollHandleBase;
class TrackSysCommonData;
class SoMaterial;
class SoNode;
class TrackLODHandle;
 
namespace Trk {
  class Track;
  class FitQuality;
  class RIO_OnTrack;
}
 
namespace MuonGM {   
  class MuonReadoutElement;
}
 
class TrackHandleBase {
public:
 
  static int numberOfInstances();
 
  TrackHandleBase(TrackCollHandleBase*);
  virtual ~TrackHandleBase();
 
  TrackSysCommonData * common() const;
 
  void setVisible(bool);
  bool visible() const { return m_visible; }
  TrackCollHandleBase * collHandle() const { return m_collhandle; }
  const std::set<GeoPVConstLink>& touchedMuonChambers() const;
  void update3DObjects(bool invalidatePropagatedPoints = false, float maxR=0.0);
  void updateInDetProjections();
  void updateMuonProjections();
  void updateMaterial();
  void rerandomiseRandomMaterial();
  void updateRandomColourTransparencyAndBrightness();
  SoMaterial * currentMaterial() const { return m_currentmaterial; }
 
  QStringList baseInfo() const;
  virtual QStringList clicked() const = 0;
 
  virtual Amg::Vector3D momentum() const { return Amg::Vector3D(0,0,0); }
  virtual std::optional<Amg::Vector3D> startPoint() const;
  virtual std::optional<Amg::Vector3D> endPoint() const;
  virtual int pdgCode() const { return 0; }
 
  //Default implementation of the following two methods will based on
  //pdgCode(). In the case of charge(), if it can't be determined
  //based on pdgCode(), and attempt will be made by looking at the
  //first track parameters charge (if a Trk::Track is
  //provided). Override in case the charge/mass can be determined, but
  //the pdg code not. (or if there is a faster way to get the charge than by constructing the Trk::Track first).
  //
  //NB: update: it is the calculateCharge() method which must be reimplemented for the charge!
  double charge() const;//Returns unknown() in case of trouble.
  virtual double mass() const;//Returns unknown() in case of trouble.
 
  bool hasCharge() const { return charge()!=unknown(); }
  bool hasMass() const { return mass()!=unknown(); }
 
  static double unknown() { return -999.0; }
 
  virtual bool hasSubSystemHitInfo() const { return false; }
  virtual bool isRun4EDM() const { return false; }
  virtual bool isIDTrack() const ;
  virtual unsigned getNPixelHits() const { return 0; }
  virtual unsigned getNSCTHits() const { return 0; }
  virtual unsigned getNTRTHits() const { return 0; }
  virtual unsigned getNMuonHits() const { return (getNMDTHits()+getNRPCHits()+getNTGCHits()+getNCSCHits()+getNMMHits()+getNsTGCHits()); }
  virtual unsigned getNMuonPhiHits() const { return 0; } 
  virtual unsigned getNMDTHits() const { return 0; }
  virtual unsigned getNRPCHits() const { return 0; }
  virtual unsigned getNTGCHits() const { return 0; }
  virtual unsigned getNCSCHits() const { return 0; }
  virtual unsigned getNMMHits() const { return 0; }
  virtual unsigned getNsTGCHits() const { return 0; }
  virtual unsigned getNMuonPrecisionHits() const { return getNMDTHits() + getNCSCHits(); } // This should really only count eta csc hits. 
  virtual const Trk::FitQuality* getFitQuality() const {return nullptr;}
  virtual const MuonGM::MuonReadoutElement* getMuonReadoutElement(const Trk::RIO_OnTrack& mb) const;
 
  QList<AssociatedObjectHandleBase*>  getVisibleMeasurements() const;
  TrackCommonFlags::TSOSPartsFlags shownTSOSParts() const;
  TrackCommonFlags::TSOSPartsFlags customColouredTSOSParts() const;
 
  std::vector< Amg::Vector3D > * hackGetPointsPropagated();
  
  virtual QString shortInfo() const { return QString("Not yet implemented"); } 
  virtual QString type() const { return QString("Not yet implemented"); } 
  
  // Object browser code
  // @TODO revisit this once plan for more general approach is completed.
  virtual void fillObjectBrowser(QList<QTreeWidgetItem *>& list); 
  virtual void updateObjectBrowser(){};
  QTreeWidgetItem* browserTreeItem() const ;
  
protected:
 
  virtual double calculateCharge() const;
  
  //Ways of providing path information:
  // * Provide a Trk::Track
  // * Provide a vector of Amg::Vector3D (this precludes extrapolation) // BEFORE EIGEN MIGRATION WAS: HepGeom::Point3D<double>'s
  //
  //Override exactly one of the two following methods, in order to
  //provide path information. It will be called exactly once and the
  //derived class destructor will be responsible of any necessary
  //memory cleanup of the returned objects:
  virtual const Trk::Track *              provide_pathInfoTrkTrack() const { return nullptr; };
  //  virtual const std::vector< HepGeom::Point3D<double> > * provide_pathInfoPoints() const { return 0; }
  virtual const std::vector< Amg::Vector3D > * provide_pathInfoPoints() { return nullptr; }

  virtual Trk::ParticleHypothesis extrapolationParticleHypothesis() const;
 
  virtual void ensureTouchedMuonChambersInitialised() const {};
  void registerTouchedMuonChamber(const GeoPVConstLink&) const;
 
  virtual void visibleStateChanged();
  virtual void currentMaterialChanged() {};
 
  const QList<AssociatedObjectHandleBase*>& getAllAscObjHandles() const; 
 
  virtual bool containsDetElement(const QString&) const {return false; }
private:
 
  // It is illegal to copy/assign a TrackHandleBase:
  TrackHandleBase(const TrackHandleBase & );
  TrackHandleBase & operator= (const TrackHandleBase & );
 
  friend class AssocObjAttachmentHandle;
  class Imp;
  Imp * m_d;
 
 
  //Here for inlining:
  bool m_visible;
  TrackCollHandleBase * m_collhandle;
  SoMaterial * m_currentmaterial;
  void clearLine();
  void registerTrack();
 
  void updateShapes_TSOSWithMeasurements();
  void updateShapes_TSOSWithErrors();
  void updateShapes_TSOSWithMaterialEffects();
  void setShownTSOSParts(TrackCommonFlags::TSOSPartsFlags f);
  void setCustomColouredTSOSParts(TrackCommonFlags::TSOSPartsFlags f);
 
  //For associated objects:
  friend class AssociatedObjectHandleBase;
  friend class TrackCollHandleBase; // Troels: maybe not needed...
  /*** Returns the attachment handle for the given region index and crossover value.
  * @param regionIndex: The region index is used to determine the region of the attachment in the detector.
  * @param crossoverval: The crossover value is used to determine the level of detail of the track.
  **/
  AssocObjAttachmentHandle * getAttachmentHandle(int regionIndex, const double& crossoverval);
protected:
  void registerAssocObject(AssociatedObjectHandleBase*);
  virtual void ensureInitTSOSs(std::unique_ptr<std::vector<AssociatedObjectHandleBase*>>&); 
};
 
class AssocObjAttachmentHandle {
public:
  void attachNodes( SoNode*simple, SoNode*detailed, bool unpickable );
  void setPickableStateOfNodes( SoNode*simple, SoNode*detailed, bool unpickable );
  void detachNodes( SoNode*simple, SoNode*detailed );
private:
  friend class TrackHandleBase;//The life of these classes are entirely owned by TrackHandleBase.
  friend class TrackHandleBase::Imp;//The life of these classes are entirely owned by TrackHandleBase.
  AssocObjAttachmentHandle(TrackLODHandle *,TrackHandleBase* );
  ~AssocObjAttachmentHandle();
  AssocObjAttachmentHandle(const AssocObjAttachmentHandle & );
  AssocObjAttachmentHandle & operator= (const AssocObjAttachmentHandle & );
  void trackMaterialChanged();
  void trackVisibilityChanged();
  class Imp;
  Imp * m_d;
};
 
 
#endif