TrackHandleBase::Imp Class Reference

Collaboration diagram for TrackHandleBase::Imp:

Public Member Functions
	Imp (TrackHandleBase *tc)
	~Imp ()
void	ensureInitPointsRaw ()
void	ensureInitPointsPropagated ()
void	ensureInitPointsProjections_InDet (bool raw)
void	ensureInitPointsProjections_Muon (bool raw)
void	materialChanged ()
void	rebuild3DObjects ()
void	attach3DObjects ()
void	detach3DObjects ()
void	addPathToSoLineSetAndSoVertexProperty (const std::vector< Amg::Vector3D > &points, int &iver, int &numlines, SoLineSet *, SoVertexProperty *) const
void	addPathsToSoLineSetAndSoVertexProperty (const Amg::SetVectorVector3D *paths, int &iver, int &numlines, SoLineSet *, SoVertexProperty *) const
SoMaterial *	determineMaterial ()
void	ensureLoadPathInfo ()
AscObj_TSOS *	addTSOS (const Trk::TrackStateOnSurface *tsos, unsigned index) const

Static Public Member Functions
static void	convertLineSetToCylinders (SoLineSet *line, SoSeparator *sep, const double &cylradius)
static double	dist (const SbVec3f &p1, const SbVec3f &p2)
static bool	isSane (const Amg::Vector3D &p)

Public Attributes
TrackHandleBase *	theclass
bool	chargeinit
double	charge
bool	massinit
double	mass
SoLineSet *	line
SoSeparator *	extraRepresentation
SoSeparator *	extrapSurfaces_sep
	for debugging.
bool	extraRepAttached
std::vector< Amg::Vector3D > *	points_raw
std::vector< Amg::Vector3D > *	points_propagated
Amg::SetVectorVector3D *	points_raw_id_projections
Amg::SetVectorVector3D *	points_raw_muon_projections
Amg::SetVectorVector3D *	points_propagated_id_projections
Amg::SetVectorVector3D *	points_propagated_muon_projections
std::set< GeoPVConstLink >	touchedmuonchambers
bool	inittouchedchambers
SoMaterial *	randommaterial
QList< AssociatedObjectHandleBase * >	associatedObjects
std::map< std::pair< int, double >, AssocObjAttachmentHandle * >	attachmentHandles
bool	pathInfoLoaded
const Trk::Track *	pathInfo_TrkTrack
	Used in the case of a Trk::Track.
const std::vector< Amg::Vector3D > *	pathInfo_Points
	Used in all other cases.
SoSeparator *	label_sep
TrackCommonFlags::TSOSPartsFlags	shownTSOSParts
TrackCommonFlags::TSOSPartsFlags	customColouredTSOSParts
std::vector< AssociatedObjectHandleBase * > *	tsos_ascobjs
QTreeWidgetItem *	m_objBrowseTree
float	tempMaxPropRadius

Static Public Attributes
static int	ntrackhandles = 0

Detailed Description

Definition at line 76 of file TrackHandleBase.cxx.

Constructor & Destructor Documentation

Imp()

TrackHandleBase::Imp::Imp ( TrackHandleBase * tc )

inline

Definition at line 83 of file TrackHandleBase.cxx.

                          : theclass(tc),
    chargeinit(false),
    charge(TrackHandleBase::unknown()),
    massinit(false),
    mass(TrackHandleBase::unknown()),
    line(nullptr),
    extraRepresentation(nullptr),
    extrapSurfaces_sep(nullptr),
    extraRepAttached(false),
    points_raw(nullptr), points_propagated(nullptr),
    points_raw_id_projections(nullptr),
    points_raw_muon_projections(nullptr),
    points_propagated_id_projections(nullptr),
    points_propagated_muon_projections(nullptr),
    inittouchedchambers(false),
    randommaterial(nullptr),
    pathInfoLoaded(false),
    pathInfo_TrkTrack(nullptr),
    pathInfo_Points(nullptr),
    label_sep(nullptr),
    shownTSOSParts(TrackCommonFlags::TSOS_NoObjects),
    customColouredTSOSParts(TrackCommonFlags::TSOS_NoObjects),
    tsos_ascobjs(nullptr),
    m_objBrowseTree(nullptr),
    tempMaxPropRadius(0.0){}

~Imp()

TrackHandleBase::Imp::~Imp ( )

inline

Definition at line 108 of file TrackHandleBase.cxx.

{ delete tsos_ascobjs; }

Member Function Documentation

addPathsToSoLineSetAndSoVertexProperty()

void TrackHandleBase::Imp::addPathsToSoLineSetAndSoVertexProperty	(	const Amg::SetVectorVector3D *	paths,
		int &	iver,
		int &	numlines,
		SoLineSet *	line,
		SoVertexProperty *	vertices ) const

Definition at line 620 of file TrackHandleBase.cxx.

{
  if ( !paths || ( paths->size()==1 && paths->begin()->empty()) )
    return;
  if (!line) {
    theclass->collHandle()->systemBase()->message("TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty (2) ERROR: Unexpected null SoLineSet pointer!");
    return;
  }
  if (!vertices) {
    theclass->collHandle()->systemBase()->message("TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty (2) ERROR: Unexpected null SoVertexPropery pointer!");
    return;
  }
  Amg::SetVectorVector3D::const_iterator itProjPart, itProjPartEnd(paths->end());
  for (itProjPart = paths->begin();itProjPart!=itProjPartEnd;++itProjPart)
    addPathToSoLineSetAndSoVertexProperty(*itProjPart,iver,numlines,line,vertices);
}

addPathToSoLineSetAndSoVertexProperty()

void TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty	(	const std::vector< Amg::Vector3D > &	points,
		int &	iver,
		int &	numlines,
		SoLineSet *	line,
		SoVertexProperty *	vertices ) const

Definition at line 556 of file TrackHandleBase.cxx.

{
  if (points.size()<2)
    return;
  if (!line) {
    theclass->collHandle()->systemBase()->message("TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty (1) ERROR: Unexpected null SoLineSet pointer!");
    return;
  }
  if (!vertices) {
    theclass->collHandle()->systemBase()->message("TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty (1) ERROR: Unexpected null SoVertexPropery pointer!");
    return;
  }
  std::vector<Amg::Vector3D >::const_iterator pointsIt, pointsItEnd(points.end());
  unsigned npointsused(0);
 
 
  float maxR2=theclass->common()->controller()->propMaxRadius()>0.0?theclass->common()->controller()->propMaxRadius():std::numeric_limits<float>::max();
  if (tempMaxPropRadius>0.0){
    maxR2 = tempMaxPropRadius * tempMaxPropRadius;
    theclass->collHandle()->systemBase()->messageVerbose("maxR2 is set to "+VP1Msg::str(maxR2));
  }
  float vertexPlanePhi = (theclass->common()->controller()->vertexProjectionAngle())*M_PI/180;// angle of plane to use for vertex projection
  vertexPlanePhi-=M_PI; // ATLAS range is -PI to PI
 
  // debug msgs:
  // theclass->collHandle()->systemBase()->messageVerbose("TrackHandleBase::Imp::addPathToSoLineSetAndSoVertexProperty - adding "
  //     +VP1Msg::str(points.size())+" points up to R2 of "+VP1Msg::str(maxR2));
  theclass->collHandle()->systemBase()->messageVerbose("Vertex projection is set to "+VP1Msg::str(vertexPlanePhi));
 
  // unsigned int count=0; // for the debug msgs below
 
  //For vertex projection
  Amg::Vector3D tempPoint;
 
  double trkPhi =  theclass->momentum().phi(); // some tracks curve between sections otherwise.
  double newPhi= vertexPlanePhi+M_PI;
  if (cos(vertexPlanePhi-trkPhi)>0) newPhi=vertexPlanePhi;
  // theclass->collHandle()->systemBase()->messageVerbose("Vertex projection is set to "+VP1Msg::str(vertexPlanePhi)+" trkPhi= "+VP1Msg::str(trkPhi)+" newPhi="+VP1Msg::str(newPhi)); // debug msg
 
  for (pointsIt = points.begin();pointsIt!=pointsItEnd && pointsIt->mag2()<maxR2; ++pointsIt) {
    // theclass->collHandle()->systemBase()->messageVerbose(VP1Msg::str(count++)+": point has perp2="+VP1Msg::str(pointsIt->perp2())); // debug msg
    if (!isSane(*pointsIt)) {
      theclass->collHandle()->systemBase()->message("WARNING: Ignoring point on track:"+VP1Msg::str( *pointsIt ) );
      continue;
    }
 
    if (theclass->collHandle()->parts() & TrackCommonFlags::VertexProjections){
      tempPoint = *pointsIt;
      Amg::setPhi(tempPoint, newPhi);
 
    // std::cout<<trkPhi<<"\t"<<phi<<"\t"<<r0<<"\t"<<r1<<"\t"<<r2<<"\t"<<r3<<"\t"<<rotatePhi<<"\t"<<tempPoint.getPhi()<<std::endl; // debug msg
 
      vertices->vertex.set1Value(iver++,tempPoint.x(),tempPoint.y(),tempPoint.z());
    } else {
      vertices->vertex.set1Value(iver++,pointsIt->x(),pointsIt->y(),pointsIt->z());
    }
    ++npointsused;
  }
  line->numVertices.set1Value(numlines++,npointsused);
}

addTSOS()

AscObj_TSOS * TrackHandleBase::Imp::addTSOS	(	const Trk::TrackStateOnSurface *	tsos,
		unsigned	index ) const

Definition at line 423 of file TrackHandleBase.cxx.

{
  AscObj_TSOS* ao = new AscObj_TSOS(theclass,tsos,index);
  theclass->registerAssocObject(ao);
  tsos_ascobjs->push_back(ao);
  if (ao->parts()&shownTSOSParts)
    ao->setVisible(true);
  return ao;
}

attach3DObjects()

void TrackHandleBase::Imp::attach3DObjects

(

)

Definition at line 900 of file TrackHandleBase.cxx.

{
    VP1Msg::messageDebug("TrackHandleBase::Imp::attach3DObjects() - 1");
 
  if (!theclass->m_currentmaterial) {
    theclass->m_currentmaterial = determineMaterial();
    theclass->m_currentmaterial->ref();
    materialChanged();
  }
  if (line && theclass->m_collhandle->sephelper()) {
      VP1Msg::messageDebug("TrackHandleBase::Imp::attach3DObjects() - 2");
    theclass->m_collhandle->sephelper()->addNodeUnderMaterial(line,theclass->m_currentmaterial);
    double tube_r(theclass->m_collhandle->trackTubeRadius());
    if (tube_r) {
      if (extraRepresentation) {
        extraRepresentation->removeAllChildren();
      } else {
        extraRepresentation = new SoSeparator;
        extraRepresentation->ref();
        theclass->common()->registerTrack(extraRepresentation,theclass);
      }
      convertLineSetToCylinders(line,extraRepresentation,tube_r);
      if (!extraRepAttached) {
        theclass->m_collhandle->sephelper()->addNodeUnderMaterial(extraRepresentation,theclass->m_currentmaterial);
        extraRepAttached=true;
      }
    }
  }
  if (label_sep && theclass->common()->textSep() && theclass->common()->controller()->doTrackLabels())
    theclass->common()->textSep()->addChild(label_sep);
 
  if (extrapSurfaces_sep) theclass->m_collhandle->sephelper()->addNodeUnderMaterial(extrapSurfaces_sep,theclass->m_currentmaterial);
}

convertLineSetToCylinders()

void TrackHandleBase::Imp::convertLineSetToCylinders ( SoLineSet * line, SoSeparator * sep, const double & cylradius )

static

Definition at line 851 of file TrackHandleBase.cxx.

{
  //TODO:  belongs in VP1Utils
  SoVertexProperty *vertices = static_cast<SoVertexProperty *>(line->vertexProperty.getValue());
  if (!vertices)
    return;
  int ivert(0);
  SbMatrix  lastTransf;
  lastTransf.makeIdentity();
 
  for (int iline=0;iline<line->numVertices.getNum();++iline) {
    int nvert=line->numVertices[iline];
    if (nvert<2) {
      ivert += nvert;
      continue;
    }
    for (int jvert= ivert; jvert<ivert+nvert-1;++jvert) {
      SbVec3f p1 = vertices->vertex[jvert].getValue();
      SbVec3f p2 = vertices->vertex[jvert+1].getValue();
      SoCylinder * cyl = new SoCylinder;
      cyl->radius = cylradius;
      const double l(dist(p1,p2));
      cyl->height = l;
      //First translate (0,l/2,0), then rotate (0,1,0) into (p2-p1), then translate p1.:
      SbMatrix m;
      m.setTranslate(SbVec3f(0,0.5*l,0));
      SbVec3f v(p2); v -= p1;
      SbRotation rot(SbVec3f(0,1,0),v);
      SbMatrix m2; m2.setRotate(rot);
      m.multRight(m2);
      SbMatrix m3;
      m3.setTranslate(p1);
      m.multRight(m3);
      //m is the transform we need in front of our cylinder. 
      //However, we need to first add the inverse of all previous transforms.
      SbMatrix mat;
      mat = m;
      mat.multRight(lastTransf.inverse());
      SoMatrixTransform * mt = new SoMatrixTransform;
      mt->matrix.setValue(mat);
      sep->addChild(mt);
      sep->addChild(cyl);
      lastTransf = m;
    }
    ivert += nvert;
  }
}

detach3DObjects()

void TrackHandleBase::Imp::detach3DObjects

(

)

Definition at line 935 of file TrackHandleBase.cxx.

{
  if (!theclass->m_currentmaterial)
    return;//Can never have been attached!
  if (line && theclass->m_collhandle->sephelper()) {
    theclass->m_collhandle->sephelper()->removeNodeUnderMaterial(line,theclass->m_currentmaterial);
    if (extraRepresentation&&extraRepAttached) {
      theclass->m_collhandle->sephelper()->removeNodeUnderMaterial(extraRepresentation,theclass->m_currentmaterial);
      extraRepAttached=false;
    }
  }
  if (label_sep && theclass->common()->textSep())
    theclass->common()->textSep()->removeChild(label_sep);
 
  if (extrapSurfaces_sep)
    theclass->m_collhandle->sephelper()->removeNodeUnderMaterial(extrapSurfaces_sep,theclass->m_currentmaterial);
}

determineMaterial()

SoMaterial * TrackHandleBase::Imp::determineMaterial

(

)

Definition at line 1286 of file TrackHandleBase.cxx.

{
  // debug msg:
  // theclass->collHandle()->systemBase()->message("determineMaterial with material = "+QString::number(static_cast<unsigned int>(theclass->collHandle()->colourBy()))); //too verbose. EJWM.
 
    int pdgcode(0);
    switch(theclass->collHandle()->colourBy()) {
 
        case TrackCollHandleBase::COLOUR_BYPID:
            pdgcode = theclass->pdgCode();
            return theclass->common()->controller()->getMaterialForPDGCode(pdgcode == SimBarCode::unknownPDG ? 0 : pdgcode);
 
        case TrackCollHandleBase::COLOUR_RANDOM:
            if (!randommaterial) {
                randommaterial = new SoMaterial;
                randommaterial->ref();
                theclass->rerandomiseRandomMaterial();
            }
            return randommaterial;
 
        case TrackCollHandleBase::COLOUR_CHARGE:
            return theclass->common()->controller()->getMaterialForCharge(theclass->hasCharge()?theclass->charge():0.0);
        case TrackCollHandleBase::COLOUR_MOMENTUM:
            return theclass->common()->controller()->getMaterialForMomentum(theclass->momentum().mag());
 
        case TrackCollHandleBase::COLOUR_DISTANCE:
            {
                // debug code:
                // AscObjSelectionManager* selManager=  theclass->common()->ascObjSelectionManager();
                //      TrackHandleBase* handle = 0;
                //      if ( selManager ) {
                //        QList<AssociatedObjectHandleBase*> selection = selManager->currentSelection();
                //        if (!selection.empty()) handle = selection[0]->trackHandle(); // Take first at the moment, but should loop and colour by all. FIXME!
                //        else theclass->collHandle()->systemBase()->message("Empty selection!");
                //      } else {
                //        theclass->collHandle()->systemBase()->message("No AscObjSelectionManager");
                //      }
 
                TrackHandleBase* handle = theclass->common()->lastSelectedTrackHandle();
                if (handle==nullptr) {
                    //theclass->collHandle()->systemBase()->message("No previously selected track.");
                    return theclass->collHandle()->material(); // use collection colouring
                }
 
                Amg::Vector3D selectedTrackMom = handle->momentum();
                Amg::Vector3D thisTrackMom     = theclass->momentum();
 
                float phiDistance  =  sqrt ( pow( selectedTrackMom.phi() - thisTrackMom.phi(),2) );
                float etaDistance  =  sqrt ( pow( selectedTrackMom.eta() - thisTrackMom.eta(),2) );
 
                //theclass->collHandle()->systemBase()->message("Distance "+QString::number(distance)); // debug msg
                float colScale=std::max(0.0, std::min(1.0,phiDistance/(M_PI))); // means that min scale is reached 0.5 of total possible distance away.
                float brightness= std::max(0.2, 1.0-(etaDistance/5.0) );
                //theclass->collHandle()->systemBase()->message("Distance "+QString::number(distance)+"\t brightness "+QString::number(brightness)); // debug msg
 
                SoMaterial* mat = new SoMaterial;
                mat->ref();
 
                // get colour of collection.
                const SbColor& col=theclass->collHandle()->material()->diffuseColor[0];
                float r,g,b;
                col.getValue(r,g,b);
 
                double r3,g3,b3;
                if (colScale>0.01) {
 
                    //Use QColor to get HSL
                    QColor tempCol = QColor::fromRgbF( r,g,b );
                    double h,s,v;
                    tempCol.getHsvF(&h,&s,&v);
 
                    //get opposite hue for farthest away points.
                    h+=0.5;
                    if (h>1.0) h-=1.0;
                    tempCol.setHsvF(h,s,v);
                    double r2,g2,b2;
                    tempCol.getRgbF(&r2,&g2,&b2);
 
                    // closest will have collection colour - far away will have opposite colour
                    r3 = r+(r2-r)*colScale;
                    b3 = b+(b2-b)*colScale;
                    g3 = g+(g2-g)*colScale;
 
                } else {
                    // too close - take default values
                    r3=r;b3=b;g3=g;
                }
 
                VP1MaterialButton::setMaterialParameters(mat,r3*brightness,g3*brightness,b3*brightness,
                        theclass->collHandle()->collMaterialBrightness(),
                        theclass->collHandle()->collMaterialTransparency());
 
                return mat;
            }
        case TrackCollHandleBase::COLOUR_VERTEX:
            {
                SoMaterial* mat = theclass->common()->system()->materialFromVertex(theclass);
                if (mat)
                    return mat;
                else
                    return theclass->collHandle()->material();
            }
        case TrackCollHandleBase::COLOUR_PERCOLLECTION:
        default:
            return theclass->collHandle()->material();
    }
}

dist()

double TrackHandleBase::Imp::dist ( const SbVec3f & p1, const SbVec3f & p2 )

static

Definition at line 842 of file TrackHandleBase.cxx.

{
  float x1,x2,y1,y2,z1,z2;
  p1.getValue(x1,y1,z1);
  p2.getValue(x2,y2,z2);
  return sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)+(z2-z1)*(z2-z1));
}

ensureInitPointsProjections_InDet()

void TrackHandleBase::Imp::ensureInitPointsProjections_InDet

(

bool

raw

)

Definition at line 1094 of file TrackHandleBase.cxx.

{
  if (raw?points_raw_id_projections:points_propagated_id_projections)
    return;
 
  raw ? ensureInitPointsRaw() : ensureInitPointsPropagated();
 
  //First check if we use same points for raw/propagated modes:
  if (points_propagated==points_raw) {
    if (raw) {
      if (points_propagated_id_projections) {
        points_raw_id_projections = points_propagated_id_projections;
        return;
      }
    } else {
      if (points_raw_id_projections) {
        points_propagated_id_projections = points_raw_id_projections;
        return;
      }
    }
  }
 
  //Time for the hard work:
  std::vector<Amg::Vector3D > * points=nullptr;
  Amg::SetVectorVector3D* projections=nullptr;
  if (raw) {
    points_raw_id_projections = new Amg::SetVectorVector3D;
    points = points_raw;
    projections = points_raw_id_projections;
  } else {
    points_propagated_id_projections = new Amg::SetVectorVector3D;
    points = points_propagated;
    projections = points_propagated_id_projections;
  }
 
  if ( !points || points->empty() || points->size()<2 ) {
    projections->clear();
    projections->insert(std::vector<Amg::Vector3D >());//error signature
    return;
  }
 
  bool oneok(false);
  if (theclass->common()->indetProjHelper_Pixel()) {
    theclass->common()->indetProjHelper_Pixel()->projectPath(*points,*projections);
    oneok = true;
  }
  if (theclass->common()->indetProjHelper_SCT()) {
    theclass->common()->indetProjHelper_SCT()->projectPath(*points,*projections);
    oneok = true;
  }
  if (theclass->common()->indetProjHelper_TRT()) {
    theclass->common()->indetProjHelper_TRT()->projectPath(*points,*projections);
    oneok = true;
  }
 
  if (!oneok) {
    projections->clear();
    projections->insert(std::vector<Amg::Vector3D >());//error signature
  }
}

ensureInitPointsProjections_Muon()

void TrackHandleBase::Imp::ensureInitPointsProjections_Muon

(

bool

raw

)

Definition at line 1156 of file TrackHandleBase.cxx.

{
  if (raw?points_raw_muon_projections:points_propagated_muon_projections)
    return;
 
  raw ? ensureInitPointsRaw() : ensureInitPointsPropagated() ;
 
  //First check if we use same points for raw/propagated modes:
  if (points_propagated==points_raw) {
    if (raw) {
      if (points_propagated_muon_projections) {
        points_raw_muon_projections = points_propagated_muon_projections;
        return;
      }
    } else {
      if (points_raw_muon_projections) {
        points_propagated_muon_projections = points_raw_muon_projections;
        return;
      }
    }
  }
 
  //Time for the hard work:
  std::vector<Amg::Vector3D > * points;
  Amg::SetVectorVector3D * projections;
  if (raw) {
    points_raw_muon_projections = new Amg::SetVectorVector3D;
    points = points_raw;
    projections = points_raw_muon_projections;
  } else {
    points_propagated_muon_projections = new Amg::SetVectorVector3D;
    points = points_propagated;
    projections = points_propagated_muon_projections;
  }
 
  MuonChamberProjectionHelper * projhelper = theclass->common()->muonChamberProjectionHelper();
  if ( !VP1JobConfigInfo::hasMuonGeometry() || !projhelper || !points || points->empty() ) {
    projections->insert(std::vector<Amg::Vector3D >());//error signature
    return;
  }
 
  //Temporary variables:
  Amg::Vector3D firstEndWall_pointA, firstEndWall_pointB;
  Amg::Vector3D secondEndWall_pointA, secondEndWall_pointB;
  bool outsidechamber;
  std::vector<Amg::Vector3D > proj1, proj2;
 
  //For each (MDT) chamber we try to project all line segments on "points" to the ends of that chamber.
  for (std::set<GeoPVConstLink>::iterator it=theclass->touchedMuonChambers().begin(); it!=theclass->touchedMuonChambers().end(); ++it){
 
    //For now, only project to end of MDT chambers:
    if (!projhelper->isKnownMDTChamber(*it))
      continue;
 
    proj1.clear();
    proj2.clear();
 
    // now loop over the stored points
    std::vector<Amg::Vector3D >::const_iterator  pointsIt=points->begin(), pointsItEnd=points->end()-1;
    for (;pointsIt!=pointsItEnd; ++pointsIt) {
 
      // Do projections
      bool ok = projhelper->projectAndConstrainLineSegmentToMDTChamberEndWalls( *it, *pointsIt, *(pointsIt+1),
        firstEndWall_pointA, firstEndWall_pointB,
        secondEndWall_pointA, secondEndWall_pointB,
        outsidechamber );
 
      if (!ok) {
        theclass->collHandle()->systemBase()->message("TrackHandleBase Error: "
          "Problems with projectAndConstrainLineSegmentToMDTChamberEndWalls(..)");
  //  projections->clear();
  //  projections->push_back(std::vector<Amg::Vector3D >);//error signature
        continue;
      }
 
      if (!outsidechamber){
        if ( proj1.empty() ) {
          proj1.push_back(firstEndWall_pointA); proj1.push_back(firstEndWall_pointB);
        } else {
          if ( proj1[proj1.size()-1] == firstEndWall_pointA ) {
            proj1.push_back(firstEndWall_pointB);//Keep adding to line part
          } else {
      //Start new line.
            projections->insert(proj1); proj1.clear();
            proj1.push_back(firstEndWall_pointA); proj1.push_back(firstEndWall_pointB);
          }
        }
        if ( proj2.empty() ) {
          proj2.push_back(secondEndWall_pointA); proj2.push_back(secondEndWall_pointB);
        } else {
        // unsure about this change...coverity 16206, sroe
        // if ( proj2[proj2.size()-1] == firstEndWall_pointA ) {
          if ( proj2[proj2.size()-1] == secondEndWall_pointA ) {
            proj2.push_back(secondEndWall_pointB);//Keep adding to line part
          } else {
      //Start new line.
            projections->insert(proj2); proj2.clear();
            proj2.push_back(secondEndWall_pointA); proj2.push_back(secondEndWall_pointB);
          }
        }
      }
      //proj2 fixme
    }
    if ( !proj1.empty() ) {
      projections->insert(proj1);
    }
    if ( !proj2.empty() ) {
      projections->insert(proj2);
    }
  }
}

ensureInitPointsPropagated()

void TrackHandleBase::Imp::ensureInitPointsPropagated

(

)

Definition at line 1062 of file TrackHandleBase.cxx.

{
  if (points_propagated)
    return;
 
  ensureLoadPathInfo();
 
  if (pathInfo_TrkTrack) {
    points_propagated = new std::vector<Amg::Vector3D >();
    bool ok (false);
    if (theclass->hasCharge()&&theclass->charge()!=0.0)
      ok = theclass->common()->trackPropagationHelper()->makePointsCharged(*points_propagated,pathInfo_TrkTrack,
              theclass->collHandle()->propagator(),
              theclass->extrapolationParticleHypothesis(),
              !theclass->collHandle()->ignoreMEOTinProp(),
              theclass->collHandle()->extendTracks() ? theclass->common()->controller()->extrapolateToThisVolume() : nullptr );
    else
      ok = theclass->common()->trackPropagationHelper()->makePointsNeutral(*points_propagated,pathInfo_TrkTrack);
 
    if (!ok) {
      delete points_propagated;
      ensureInitPointsRaw();
      points_propagated = points_raw;
    }
  } else {
    //We just use the raw points:
    ensureInitPointsRaw();
    points_propagated = points_raw;
  }
}

ensureInitPointsRaw()

void TrackHandleBase::Imp::ensureInitPointsRaw

(

)

Definition at line 984 of file TrackHandleBase.cxx.

{
  // debug msg:  
  // theclass->collHandle()->systemBase()->message("ensureInitPointsRaw start" );
 
  if (points_raw)
    return;
  points_raw = new std::vector<Amg::Vector3D >;

  //             Get information about this path              //
 
  ensureLoadPathInfo();
 
  if (pathInfo_TrkTrack) {
    Amg::Vector3D * firstmomentum(nullptr);
    if (pathInfo_TrkTrack->trackParameters())
      points_raw->reserve(pathInfo_TrkTrack->trackParameters()->size());
    bool unsafeparts(false);
    Trk::TrackStates::const_iterator tsos_iter = pathInfo_TrkTrack->trackStateOnSurfaces()->begin();
    Trk::TrackStates::const_iterator tsos_end = pathInfo_TrkTrack->trackStateOnSurfaces()->end();
    const Trk::TrackParameters* trackParam;
    for (; tsos_iter != tsos_end; ++tsos_iter) {
      if (!VP1TrackSanity::isSafe(*tsos_iter)) {
        unsafeparts = true;
        continue;
      }
      if (theclass->collHandle()->ignoreMEOTinProp() && (*tsos_iter)->materialEffectsOnTrack())
        continue;
      trackParam = (*tsos_iter)->trackParameters();
      if (trackParam) {
        if (!VP1TrackSanity::isSafe(trackParam)) {
          unsafeparts = true;
          continue;
        }
        trackParam->position();//test
        points_raw->push_back( trackParam->position() );
        if (!firstmomentum) {
            firstmomentum = new Amg::Vector3D(trackParam->momentum());
        }
      }
    }
    if (unsafeparts)
      theclass->collHandle()->systemBase()->message("WARNING: Ignored unsafe parts of track!");
    if (points_raw->size()==1) {
      if (!firstmomentum) {
        theclass->collHandle()->systemBase()->message(" TrackHandleBase ERROR: Unexpected null firstmomentum!");
        firstmomentum = new Amg::Vector3D(0,0,0);
      }
      if (firstmomentum->mag()==0.0) {
        theclass->collHandle()->systemBase()->message("TrackHandleBase ERROR: Only point on track had zero momentum. Can't add second point.");
        points_raw->clear();
      } else {
        VP1Msg::messageVerbose("TrackHandleBase: Adding second point in direction of initial momentum.");
        points_raw->push_back(points_raw->front()+(*firstmomentum)*(100.0/firstmomentum->mag()));
      }
    } else if (points_raw->empty()) {
      theclass->collHandle()->systemBase()->message("TrackHandleBase ERROR: No points on track.");
    }
 
    delete firstmomentum;
    firstmomentum = nullptr;
    return;
  }
  if (pathInfo_Points)
    std::copy(pathInfo_Points->begin(), pathInfo_Points->end(), std::back_inserter(*points_raw));
  if (points_raw->size()<2) {
    theclass->collHandle()->systemBase()->message("TrackHandleBase ERROR: Less than two points on track provided.");
    points_raw->clear();
  } else {
    VP1Msg::messageVerbose( "TrackHandleBase: Created raw data "
      + QString::number(points_raw->size())
      + " points for track.");
  }
}

ensureLoadPathInfo()

void TrackHandleBase::Imp::ensureLoadPathInfo

(

)

Definition at line 189 of file TrackHandleBase.cxx.

{
  if (pathInfoLoaded)
    return;
  pathInfoLoaded = true;
  pathInfo_TrkTrack = theclass->provide_pathInfoTrkTrack();
  if (pathInfo_TrkTrack)
    return;
  pathInfo_Points = theclass->provide_pathInfoPoints();
  if (!pathInfo_Points) {
    theclass->collHandle()->systemBase()->message("ERROR: No path information for track in collection "+theclass->collHandle()->name());
  }
}

isSane()

bool TrackHandleBase::Imp::isSane ( const Amg::Vector3D & p )

inlinestatic

Definition at line 164 of file TrackHandleBase.cxx.

  {
    if (p.x()!=p.x()||fabs(p.x())>1.0*CLHEP::km)
      return false;
    if (p.y()!=p.y()||fabs(p.y())>1.0*CLHEP::km)
      return false;
    if (p.z()!=p.z()||fabs(p.z())>1.0*CLHEP::km)
      return false;
    return true;
  }

materialChanged()

void TrackHandleBase::Imp::materialChanged

(

)

Definition at line 833 of file TrackHandleBase.cxx.

{
  theclass->currentMaterialChanged();
  std::map<std::pair<int,double>,AssocObjAttachmentHandle *>::iterator it,itE(attachmentHandles.end());
  for (it = attachmentHandles.begin();it!=itE;++it)
    it->second->trackMaterialChanged();
}

rebuild3DObjects()

void TrackHandleBase::Imp::rebuild3DObjects

(

)

Definition at line 658 of file TrackHandleBase.cxx.

{
  //Ensure we are always detached while updating.
  if (theclass->m_visible)
    detach3DObjects();
 
  // Make sure we're not going to redraw old surfaces, for this debug mode.
  if (theclass->common()->trackPropagationHelper()->showExtrapolationSurfaces())
    theclass->common()->trackPropagationHelper()->getExtrapolationSurfaces().clear();
 
  Trk::IExtrapolator * propagator = theclass->collHandle()->propagator();
 
  if (propagator)
    ensureInitPointsPropagated();
  else
    ensureInitPointsRaw();
 
  bool id_proj = theclass->collHandle()->parts() & TrackCommonFlags::InDetProjections;
  if (id_proj)
    ensureInitPointsProjections_InDet(!propagator);
 
  bool muon_proj = theclass->collHandle()->parts() & TrackCommonFlags::MuonProjections;
  if (muon_proj)
    ensureInitPointsProjections_Muon(!propagator);
 
  std::vector<Amg::Vector3D > * points;
  Amg::SetVectorVector3D *proj_id, *proj_muon;
  if (propagator) {
    points = points_propagated;
    proj_id = points_propagated_id_projections;
    proj_muon = points_propagated_muon_projections;
  } else {
    points = points_raw;
    proj_id = points_raw_id_projections;
    proj_muon = points_raw_muon_projections;
  }
 
  //Put points into an appropriate vertex property.
  theclass->clearLine(); //FIXME: Since we are just changing shape - no need to delete line and take it
                         //out of the tree first. Just edit lineset properties instead.
  line = new SoLineSet();
  line->ref();
  theclass->registerTrack();
 
  SoVertexProperty * vertices = new SoVertexProperty();
 
  int iver(0), numlines(0);
 
  //Add various parts to these vertices as appropriate:
  if (theclass->collHandle()->parts() & TrackCommonFlags::ActualPath)
    addPathToSoLineSetAndSoVertexProperty(*points,iver,numlines,line,vertices);
  if (id_proj)
    addPathsToSoLineSetAndSoVertexProperty( proj_id, iver, numlines, line, vertices );
  if (muon_proj)
    addPathsToSoLineSetAndSoVertexProperty( proj_muon, iver, numlines, line, vertices );
 
  line->vertexProperty = vertices;

 
 
// Add debugging surfaces.
  if (theclass->common()->trackPropagationHelper()->showExtrapolationSurfaces()){
    std::vector<Trk::PlaneSurface>& surfaces = theclass->common()->trackPropagationHelper()->getExtrapolationSurfaces();
    std::vector<Trk::PlaneSurface>::const_iterator surfIt=surfaces.begin(), surfEnd=surfaces.end();
    SurfaceToSoNode surfCnv;//fixme: check if need in common()
    extrapSurfaces_sep=new SoSeparator;
    for (;surfIt!=surfEnd;++surfIt){
      SoNode* theSurfSep = surfCnv.translateSurface(*surfIt);
      if (theSurfSep) {
        SoNode * nodeToAdd = theSurfSep;
        extrapSurfaces_sep->addChild(nodeToAdd);
      }
    }
  }
 
// Add labels
  if (!points->empty() && theclass->common()->controller()->doTrackLabels() ){
 
    // should detach first? This is all fairly suboptimal I'm sure... EJWM.
    if (!label_sep){
      label_sep = new SoSeparator;
      label_sep->ref();
    }
    label_sep->removeAllChildren ();
 
    SoText2 *labelText = new SoText2;
    labelText->ref();
    QStringList text;
    TrackSystemController::TrackLabelModes labels=theclass->common()->controller()->trackLabels();
    if (labels&TrackSystemController::P){
      text << "P="+VP1Msg::str(theclass->momentum().mag())+" MeV";
    }
 
    if (labels&TrackSystemController::Pt){
      text << "|Pt|="+VP1Msg::str(theclass->momentum().perp())+" MeV";
    }
 
    if (labels&TrackSystemController::Pid){
      int pdg = theclass->pdgCode();
      if (pdg) {
        bool ok;
        QString name = VP1ParticleData::particleName(pdg,ok);
        if (ok)
          text << "pdg: "+QString::number(pdg)+" ["+name+"]";
        else
          text << "pdg: "+QString::number(pdg);
      }
    }
 
    if (labels&TrackSystemController::FitQuality && theclass->getFitQuality()){
      text << TrkObjToString::shortInfo(*theclass->getFitQuality());
    }
 
    if (labels&TrackSystemController::Hits){
      text <<"Pix["+VP1Msg::str(theclass->getNPixelHits())+"], SCT["+VP1Msg::str(theclass->getNSCTHits())+"], TRT["+VP1Msg::str(theclass->getNTRTHits())+"],"
        <<" MDT["+QString::number(theclass->getNMDTHits())+"], RPC["+QString::number(theclass->getNRPCHits())+"], TGC["+QString::number(theclass->getNTGCHits())+"], CSC["+QString::number(theclass->getNCSCHits())+"] MM["+QString::number(theclass->getNMMHits())+"], sTGC["+QString::number(theclass->getNsTGCHits())+"]";
    }
 
      if (labels&TrackSystemController::Direction ){
        Amg::Vector3D mom = theclass->momentum();
        mom /= CLHEP::GeV;
        if (mom.mag2()==0.0) {
          text << "Momentum : 0 (undefined)";
        } else {
          // current SoCoin classes don't support Unincode here, apparently.
          // text << VP1Msg::str("(")+QChar(0x03B7)+","+QChar(0x03D5)+VP1Msg::str(")=(")
          //   +VP1Msg::str(mom.pseudoRapidity())+VP1Msg::str(VP1LinAlgUtils::phiFromXY(mom.x(), mom.y() ))+VP1Msg::str(")");
          double pseudoRapidity = mom.eta();
          text << VP1Msg::str("(eta,phi)=(")
            +VP1Msg::str(pseudoRapidity)+VP1Msg::str(",")+VP1Msg::str(VP1LinAlgUtils::phiFromXY(mom.x(), mom.y() ))+VP1Msg::str(")");
        }
      }
 
    unsigned int row=0;
    for(const QString& str : text){
      QByteArray array = str.toLatin1();
      labelText->string.set1Value(row++,array.data());
    }
 
    //Position
    float labelTrackOffset = theclass->common()->controller()->trackLabelTrkOffset();
    unsigned int point=(points->size()-1)*labelTrackOffset;
    Amg::Vector3D labelPos = (*points)[point] ;
 
// NOTE: those options can be used if we want different label positions:    
//    if (labels&TrackSystemController::PosEndOfTrack)
//      labelPos=    points->back();
//    else if (labels&TrackSystemController::PosBeginOfTrack)
//      labelPos=    points->front ();
//    else if (labels&TrackSystemController::PosMidOfTrack)
//      labelPos=    (*points)[points->size()/2];
 
    SoTranslation *labelTranslate = new SoTranslation;
    float offScale=10.0;
    int xOffset = theclass->common()->controller()->labelXOffset() ;
    int yOffset = theclass->common()->controller()->labelYOffset() ;
    int zOffset = theclass->common()->controller()->labelZOffset() ;
    labelTranslate->translation.setValue(labelPos.x()+(xOffset*offScale),labelPos.y()+(yOffset*offScale),labelPos.z()+(zOffset*offScale));
 
    SoMaterial *sMat = new SoMaterial();
    SoMFColor sColor;
    sColor.setValue(SbColor(0, 0, 1));
    sMat->diffuseColor = sColor;
 
    label_sep->addChild(labelTranslate);
    label_sep->addChild(labelText);
  }
 
  //Attach if visible:
  if (theclass->m_visible)
    attach3DObjects();
}

Member Data Documentation

associatedObjects

QList<AssociatedObjectHandleBase*> TrackHandleBase::Imp::associatedObjects

Definition at line 154 of file TrackHandleBase.cxx.

attachmentHandles

std::map<std::pair<int,double>,AssocObjAttachmentHandle *> TrackHandleBase::Imp::attachmentHandles

Definition at line 155 of file TrackHandleBase.cxx.

charge

double TrackHandleBase::Imp::charge

Definition at line 112 of file TrackHandleBase.cxx.

chargeinit

bool TrackHandleBase::Imp::chargeinit

Definition at line 111 of file TrackHandleBase.cxx.

customColouredTSOSParts

TrackCommonFlags::TSOSPartsFlags TrackHandleBase::Imp::customColouredTSOSParts

Definition at line 177 of file TrackHandleBase.cxx.

extrapSurfaces_sep

SoSeparator* TrackHandleBase::Imp::extrapSurfaces_sep

for debugging.

FIXME!

Definition at line 118 of file TrackHandleBase.cxx.

extraRepAttached

bool TrackHandleBase::Imp::extraRepAttached

Definition at line 119 of file TrackHandleBase.cxx.

extraRepresentation

SoSeparator* TrackHandleBase::Imp::extraRepresentation

Definition at line 117 of file TrackHandleBase.cxx.

inittouchedchambers

bool TrackHandleBase::Imp::inittouchedchambers

mutable

Definition at line 144 of file TrackHandleBase.cxx.

label_sep

SoSeparator* TrackHandleBase::Imp::label_sep

Definition at line 161 of file TrackHandleBase.cxx.

line

SoLineSet* TrackHandleBase::Imp::line

Definition at line 116 of file TrackHandleBase.cxx.

m_objBrowseTree

QTreeWidgetItem* TrackHandleBase::Imp::m_objBrowseTree

Definition at line 181 of file TrackHandleBase.cxx.

mass

double TrackHandleBase::Imp::mass

Definition at line 114 of file TrackHandleBase.cxx.

massinit

bool TrackHandleBase::Imp::massinit

Definition at line 113 of file TrackHandleBase.cxx.

ntrackhandles

int TrackHandleBase::Imp::ntrackhandles = 0

static

Definition at line 81 of file TrackHandleBase.cxx.

pathInfo_Points

const std::vector< Amg::Vector3D >* TrackHandleBase::Imp::pathInfo_Points

Used in all other cases.

Definition at line 160 of file TrackHandleBase.cxx.

pathInfo_TrkTrack

const Trk::Track* TrackHandleBase::Imp::pathInfo_TrkTrack

Used in the case of a Trk::Track.

Definition at line 159 of file TrackHandleBase.cxx.

pathInfoLoaded

bool TrackHandleBase::Imp::pathInfoLoaded

Definition at line 158 of file TrackHandleBase.cxx.

points_propagated

std::vector<Amg::Vector3D >* TrackHandleBase::Imp::points_propagated

Definition at line 125 of file TrackHandleBase.cxx.

points_propagated_id_projections

Amg::SetVectorVector3D* TrackHandleBase::Imp::points_propagated_id_projections

Definition at line 129 of file TrackHandleBase.cxx.

points_propagated_muon_projections

Amg::SetVectorVector3D* TrackHandleBase::Imp::points_propagated_muon_projections

Definition at line 130 of file TrackHandleBase.cxx.

points_raw

std::vector< Amg::Vector3D >* TrackHandleBase::Imp::points_raw

Definition at line 124 of file TrackHandleBase.cxx.

points_raw_id_projections

Amg::SetVectorVector3D* TrackHandleBase::Imp::points_raw_id_projections

Definition at line 127 of file TrackHandleBase.cxx.

points_raw_muon_projections

Amg::SetVectorVector3D* TrackHandleBase::Imp::points_raw_muon_projections

Definition at line 128 of file TrackHandleBase.cxx.

randommaterial

SoMaterial* TrackHandleBase::Imp::randommaterial

Definition at line 152 of file TrackHandleBase.cxx.

shownTSOSParts

TrackCommonFlags::TSOSPartsFlags TrackHandleBase::Imp::shownTSOSParts

Definition at line 176 of file TrackHandleBase.cxx.

tempMaxPropRadius

float TrackHandleBase::Imp::tempMaxPropRadius

Definition at line 182 of file TrackHandleBase.cxx.

theclass

TrackHandleBase* TrackHandleBase::Imp::theclass

Definition at line 109 of file TrackHandleBase.cxx.

touchedmuonchambers

std::set<GeoPVConstLink> TrackHandleBase::Imp::touchedmuonchambers

mutable

Definition at line 143 of file TrackHandleBase.cxx.

tsos_ascobjs

std::vector<AssociatedObjectHandleBase*>* TrackHandleBase::Imp::tsos_ascobjs

Definition at line 178 of file TrackHandleBase.cxx.

---

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

• TrackHandleBase.cxx