G4TrajectoryDrawerUtils Namespace Reference

Enumerations
enum	TimesValidity { InvalidTimes , ValidTimes }

Functions
void	DrawLineAndPoints (const G4VTrajectory &traj, const G4VisTrajContext &)
static void	DrawWithoutTime (const G4VisTrajContext &myContext, G4Polyline &trajectoryLine, G4Polymarker &auxiliaryPoints, G4Polymarker &stepPoints)
static void	DrawWithTime (const G4VisTrajContext &myContext, G4Polyline &trajectoryLine, G4Polymarker &auxiliaryPoints, G4Polymarker &stepPoints, std::vector< G4double > &trajectoryLineTimes, std::vector< G4double > &auxiliaryPointTimes, std::vector< G4double > &stepPointTimes)
void	GetPoints (const G4VTrajectory &traj, G4Polyline &trajectoryLine, G4Polymarker &auxiliaryPoints, G4Polymarker &stepPoints)
TimesValidity	GetPointsAndTimes (const G4VTrajectory &traj, const G4VisTrajContext &context, G4Polyline &trajectoryLine, G4Polymarker &auxiliaryPoints, G4Polymarker &stepPoints, std::vector< G4double > &trajectoryLineTimes, std::vector< G4double > &auxiliaryPointTimes, std::vector< G4double > &stepPointTimes)
static void	SliceLine (G4double timeIncrement, G4Polyline &trajectoryLine, std::vector< G4double > &trajectoryLineTimes)

Enumeration Type Documentation

TimesValidity

enum G4TrajectoryDrawerUtils::TimesValidity

Enumerator
InvalidTimes
ValidTimes

Definition at line 43 of file G4TrajectoryDrawerUtils.cc.

{InvalidTimes, ValidTimes};

Function Documentation

DrawLineAndPoints()

void G4TrajectoryDrawerUtils::DrawLineAndPoints	(	const G4VTrajectory &	traj,
		const G4VisTrajContext &	context
	)

Definition at line 314 of file G4TrajectoryDrawerUtils.cc.

  {
    // Return if don't need to do anything
    if (!context.GetDrawLine() && !context.GetDrawAuxPts() && !context.GetDrawStepPts()) return;
    
    // Get points and times (times are returned only if time-slicing
    // is requested).
    G4Polyline trajectoryLine;
    G4Polymarker stepPoints;
    G4Polymarker auxiliaryPoints;
    std::vector<G4double> trajectoryLineTimes;
    std::vector<G4double> stepPointTimes;
    std::vector<G4double> auxiliaryPointTimes;
 
    TimesValidity validity = GetPointsAndTimes
      (traj, context,
       trajectoryLine, auxiliaryPoints, stepPoints,
       trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
    
    if (validity == ValidTimes) {
 
      SliceLine(context.GetTimeSliceInterval(),
        trajectoryLine, trajectoryLineTimes);
 
      DrawWithTime(context,
           trajectoryLine, auxiliaryPoints, stepPoints,
           trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
 
    } else {
 
      DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
 
    }
  }

References g4zmq::context, DrawWithoutTime(), DrawWithTime(), GetPointsAndTimes(), SliceLine(), and ValidTimes.

Referenced by G4TrajectoryDrawByAttribute::Draw(), G4TrajectoryDrawByCharge::Draw(), G4TrajectoryDrawByEncounteredVolume::Draw(), G4TrajectoryDrawByOriginVolume::Draw(), G4TrajectoryDrawByParticleID::Draw(), and G4TrajectoryGenericDrawer::Draw().

DrawWithoutTime()

static void G4TrajectoryDrawerUtils::DrawWithoutTime ( const G4VisTrajContext &  myContext, G4Polyline &  trajectoryLine, G4Polymarker &  auxiliaryPoints, G4Polymarker &  stepPoints  )

static

Definition at line 208 of file G4TrajectoryDrawerUtils.cc.

  {
    // Draw without time slice information
 
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if (0 == pVVisManager) return;
    
    if (myContext.GetDrawLine() && myContext.GetLineVisible()) {
      G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
      trajectoryLineAttribs.SetLineWidth(myContext.GetLineWidth());
      trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
 
      pVVisManager->Draw(trajectoryLine);
    }
  
    if (myContext.GetDrawAuxPts() && myContext.GetAuxPtsVisible()
        && (auxiliaryPoints.size() > 0)) {
      auxiliaryPoints.SetMarkerType(myContext.GetAuxPtsType());
      auxiliaryPoints.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
      auxiliaryPoints.SetFillStyle(myContext.GetAuxPtsFillStyle());
 
      G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());  
      auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
 
      pVVisManager->Draw(auxiliaryPoints);
    }
  
    if (myContext.GetDrawStepPts() && myContext.GetStepPtsVisible()
        && (stepPoints.size() > 0)) {
      stepPoints.SetMarkerType(myContext.GetStepPtsType());
      stepPoints.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
      stepPoints.SetFillStyle(myContext.GetStepPtsFillStyle());
 
      G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour()); 
      stepPoints.SetVisAttributes(&stepPointsAttribs);
 
      pVVisManager->Draw(stepPoints);
    }
  }

References G4VVisManager::Draw(), G4VisTrajContext::GetAuxPtsColour(), G4VisTrajContext::GetAuxPtsFillStyle(), G4VisTrajContext::GetAuxPtsSize(), G4VisTrajContext::GetAuxPtsSizeType(), G4VisTrajContext::GetAuxPtsType(), G4VisTrajContext::GetAuxPtsVisible(), G4VVisManager::GetConcreteInstance(), G4VisTrajContext::GetDrawAuxPts(), G4VisTrajContext::GetDrawLine(), G4VisTrajContext::GetDrawStepPts(), G4VisTrajContext::GetLineColour(), G4VisTrajContext::GetLineVisible(), G4VisTrajContext::GetLineWidth(), G4VisTrajContext::GetStepPtsColour(), G4VisTrajContext::GetStepPtsFillStyle(), G4VisTrajContext::GetStepPtsSize(), G4VisTrajContext::GetStepPtsSizeType(), G4VisTrajContext::GetStepPtsType(), G4VisTrajContext::GetStepPtsVisible(), G4VMarker::SetFillStyle(), G4VisAttributes::SetLineWidth(), G4Polymarker::SetMarkerType(), G4VMarker::SetSize(), and G4Visible::SetVisAttributes().

Referenced by DrawLineAndPoints().

DrawWithTime()

static void G4TrajectoryDrawerUtils::DrawWithTime ( const G4VisTrajContext &  myContext, G4Polyline &  trajectoryLine, G4Polymarker &  auxiliaryPoints, G4Polymarker &  stepPoints, std::vector< G4double > &  trajectoryLineTimes, std::vector< G4double > &  auxiliaryPointTimes, std::vector< G4double > &  stepPointTimes  )

static

Definition at line 251 of file G4TrajectoryDrawerUtils.cc.

  {
    // Draw with time slice information
 
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if (0 == pVVisManager) return;
 
    if (myContext.GetDrawLine() && myContext.GetLineVisible()) {
      G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
      trajectoryLineAttribs.SetLineWidth(myContext.GetLineWidth());
 
      for (size_t i = 1; i < trajectoryLine.size(); ++i ) {
    G4Polyline slice;
    slice.push_back(trajectoryLine[i -1]);
    slice.push_back(trajectoryLine[i]);
    trajectoryLineAttribs.SetStartTime(trajectoryLineTimes[i - 1]);
    trajectoryLineAttribs.SetEndTime(trajectoryLineTimes[i]);
    slice.SetVisAttributes(&trajectoryLineAttribs);
    pVVisManager->Draw(slice);
      }
    }
 
    if (myContext.GetDrawAuxPts() && myContext.GetAuxPtsVisible()
        && (auxiliaryPoints.size() > 0)) {
      G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());  
 
      for (size_t i = 0; i < auxiliaryPoints.size(); ++i ) {
    G4Polymarker point;
    point.push_back(auxiliaryPoints[i]);
    point.SetMarkerType(myContext.GetAuxPtsType());
    point.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
    point.SetFillStyle(myContext.GetAuxPtsFillStyle());
    auxiliaryPointsAttribs.SetStartTime(auxiliaryPointTimes[i]);
    auxiliaryPointsAttribs.SetEndTime(auxiliaryPointTimes[i]);
    point.SetVisAttributes(&auxiliaryPointsAttribs);
    pVVisManager->Draw(point);
      }
    }
 
    if (myContext.GetDrawStepPts() && myContext.GetStepPtsVisible()
        && (stepPoints.size() > 0)) {
      G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour()); 
 
      for (size_t i = 0; i < stepPoints.size(); ++i ) {
    G4Polymarker point;
    point.push_back(stepPoints[i]);
    point.SetMarkerType(myContext.GetStepPtsType());
    point.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
    point.SetFillStyle(myContext.GetStepPtsFillStyle());
    stepPointsAttribs.SetStartTime(stepPointTimes[i]);
    stepPointsAttribs.SetEndTime(stepPointTimes[i]);
    point.SetVisAttributes(&stepPointsAttribs);
    pVVisManager->Draw(point);
      }
    }
  }

References G4VVisManager::Draw(), G4VisTrajContext::GetAuxPtsColour(), G4VisTrajContext::GetAuxPtsFillStyle(), G4VisTrajContext::GetAuxPtsSize(), G4VisTrajContext::GetAuxPtsSizeType(), G4VisTrajContext::GetAuxPtsType(), G4VisTrajContext::GetAuxPtsVisible(), G4VVisManager::GetConcreteInstance(), G4VisTrajContext::GetDrawAuxPts(), G4VisTrajContext::GetDrawLine(), G4VisTrajContext::GetDrawStepPts(), G4VisTrajContext::GetLineColour(), G4VisTrajContext::GetLineVisible(), G4VisTrajContext::GetLineWidth(), G4VisTrajContext::GetStepPtsColour(), G4VisTrajContext::GetStepPtsFillStyle(), G4VisTrajContext::GetStepPtsSize(), G4VisTrajContext::GetStepPtsSizeType(), G4VisTrajContext::GetStepPtsType(), G4VisTrajContext::GetStepPtsVisible(), G4VisAttributes::SetEndTime(), G4VMarker::SetFillStyle(), G4VisAttributes::SetLineWidth(), G4Polymarker::SetMarkerType(), G4VMarker::SetSize(), G4VisAttributes::SetStartTime(), and G4Visible::SetVisAttributes().

Referenced by DrawLineAndPoints().

GetPoints()

void G4TrajectoryDrawerUtils::GetPoints	(	const G4VTrajectory &	traj,
		G4Polyline &	trajectoryLine,
		G4Polymarker &	auxiliaryPoints,
		G4Polymarker &	stepPoints
	)

GetPointsAndTimes()

TimesValidity G4TrajectoryDrawerUtils::GetPointsAndTimes	(	const G4VTrajectory &	traj,
		const G4VisTrajContext &	context,
		G4Polyline &	trajectoryLine,
		G4Polymarker &	auxiliaryPoints,
		G4Polymarker &	stepPoints,
		std::vector< G4double > &	trajectoryLineTimes,
		std::vector< G4double > &	auxiliaryPointTimes,
		std::vector< G4double > &	stepPointTimes
	)

Definition at line 45 of file G4TrajectoryDrawerUtils.cc.

  {
    TimesValidity validity = InvalidTimes;
    if (context.GetTimeSliceInterval()) validity = ValidTimes;
 
    // Memory for last trajectory point position for auxiliary point
    // time interpolation algorithm.  There are no auxiliary points
    // for the first trajectory point, so its initial value is
    // immaterial.
    G4ThreeVector lastTrajectoryPointPosition;
 
    // Keep positions.  Don't store unless first or different.
    std::vector<G4ThreeVector> positions;
 
    for (G4int iPoint=0; iPoint<traj.GetPointEntries(); iPoint++) {
 
      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(iPoint);
      const G4ThreeVector& trajectoryPointPosition =
    aTrajectoryPoint->GetPosition();
 
      // Only store if first or if different
      if (positions.size() == 0 ||
      trajectoryPointPosition != positions[positions.size()-1]) {
 
    // Pre- and Post-Point times from the trajectory point...
    G4double trajectoryPointPreTime = -std::numeric_limits<double>::max();
    G4double trajectoryPointPostTime = std::numeric_limits<double>::max();
 
    if (context.GetTimeSliceInterval() && validity == ValidTimes) {
 
      std::vector<G4AttValue>* trajectoryPointAttValues =
        aTrajectoryPoint->CreateAttValues();
      if (!trajectoryPointAttValues) {
        static G4bool warnedNoAttValues = false;
        if (!warnedNoAttValues) {
          G4cout <<
  "*************************************************************************"
  "\n*  WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: no att values."
  "\n*************************************************************************"
             << G4endl;
          warnedNoAttValues = true;
        }
        validity = InvalidTimes;
      } else {
        G4bool foundPreTime = false, foundPostTime = false;
        for (std::vector<G4AttValue>::iterator i =
           trajectoryPointAttValues->begin();
         i != trajectoryPointAttValues->end(); ++i) {
          if (i->GetName() == "PreT") {
        trajectoryPointPreTime =
          G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
        foundPreTime = true;
          }
          if (i->GetName() == "PostT") {
        trajectoryPointPostTime =
          G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
        foundPostTime = true;
          }
        }
        if (!foundPreTime || !foundPostTime) {
          static G4bool warnedTimesNotFound = false;
          if (!warnedTimesNotFound) {
        G4cout <<
  "*************************************************************************"
  "\n*  WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: times not found."
  "\n You need to specify \"/vis/scene/add/trajectories rich\""
  "\n*************************************************************************"
               << G4endl;
        warnedTimesNotFound = true;
          }
          validity = InvalidTimes;
        }
      }
          delete trajectoryPointAttValues;  // (Must be deleted after use.)
    }
 
    const std::vector<G4ThreeVector>* auxiliaries
      = aTrajectoryPoint->GetAuxiliaryPoints();
    if (0 != auxiliaries) {
      for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
        const G4ThreeVector& auxPointPosition = (*auxiliaries)[iAux];
        if (positions.size() == 0 ||
        auxPointPosition != positions[positions.size()-1]) {
          // Only store if first or if different
          positions.push_back(trajectoryPointPosition);
          trajectoryLine.push_back(auxPointPosition);
          auxiliaryPoints.push_back(auxPointPosition);
          if (validity == ValidTimes) {
        // Interpolate time for auxiliary points...
        G4double s1 =
          (auxPointPosition - lastTrajectoryPointPosition).mag();
        G4double s2 =
          (trajectoryPointPosition - auxPointPosition).mag();
        G4double t = trajectoryPointPreTime +
          (trajectoryPointPostTime - trajectoryPointPreTime) *
          (s1 / (s1 + s2));
        trajectoryLineTimes.push_back(t);
        auxiliaryPointTimes.push_back(t);
          }
        }
      }
    }
 
    positions.push_back(trajectoryPointPosition);
    trajectoryLine.push_back(trajectoryPointPosition);
    stepPoints.push_back(trajectoryPointPosition);
    if (validity == ValidTimes) {
      trajectoryLineTimes.push_back(trajectoryPointPostTime);
      stepPointTimes.push_back(trajectoryPointPostTime);
    }
        lastTrajectoryPointPosition = trajectoryPointPosition;
      }
    }
    return validity;    
  }

References g4zmq::context, G4UIcommand::ConvertToDimensionedDouble(), G4VTrajectoryPoint::CreateAttValues(), G4cout, G4endl, G4VTrajectoryPoint::GetAuxiliaryPoints(), G4VTrajectory::GetPoint(), G4VTrajectory::GetPointEntries(), G4VTrajectoryPoint::GetPosition(), InvalidTimes, G4INCL::Math::max(), and ValidTimes.

Referenced by DrawLineAndPoints().

SliceLine()

static void G4TrajectoryDrawerUtils::SliceLine ( G4double  timeIncrement, G4Polyline &  trajectoryLine, std::vector< G4double > &  trajectoryLineTimes  )

static

Definition at line 169 of file G4TrajectoryDrawerUtils.cc.

  {
    // Assumes valid arguments from GetPoints and GetTimes.
 
    G4Polyline newTrajectoryLine;
    std::vector<G4double> newTrajectoryLineTimes;
 
    newTrajectoryLine.push_back(trajectoryLine[0]);
    newTrajectoryLineTimes.push_back(trajectoryLineTimes[0]);
    size_t lineSize = trajectoryLine.size();
    if (lineSize > 1) {
      for (size_t i = 1; i < trajectoryLine.size(); ++i) {
    G4double deltaT = trajectoryLineTimes[i] - trajectoryLineTimes[i - 1];
    if (deltaT > 0.) {
      G4double practicalTimeIncrement = 
        std::max(timeIncrement, deltaT / 100.);
      for (G4double t =
         (int(trajectoryLineTimes[i - 1]/practicalTimeIncrement) + 1) *
         practicalTimeIncrement;
           t <= trajectoryLineTimes[i];
           t += practicalTimeIncrement) {
        G4ThreeVector pos = trajectoryLine[i - 1] +
          (trajectoryLine[i] - trajectoryLine[i - 1]) *
          ((t - trajectoryLineTimes[i - 1]) / deltaT);
        newTrajectoryLine.push_back(pos);
        newTrajectoryLineTimes.push_back(t);
      }
    }
    newTrajectoryLine.push_back(trajectoryLine[i]);
    newTrajectoryLineTimes.push_back(trajectoryLineTimes[i]);
      }
    }
 
    trajectoryLine = newTrajectoryLine;
    trajectoryLineTimes = newTrajectoryLineTimes;
  }

References G4INCL::Math::max(), and pos.

Referenced by DrawLineAndPoints().