G4TrajectoryDrawerUtils Namespace Reference

Enumerations
enum	TimesValidity { InvalidTimes , ValidTimes }

Functions
void	GetPoints (const G4VTrajectory &traj, G4Polyline &trajectoryLine, G4Polymarker &auxiliaryPoints, G4Polymarker &stepPoints)
void	DrawLineAndPoints (const G4VTrajectory &traj, const G4VisTrajContext &)
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)

Enumeration Type Documentation

TimesValidity

enum G4TrajectoryDrawerUtils::TimesValidity

Enumerator
InvalidTimes
ValidTimes

Definition at line 52 of file G4TrajectoryDrawerUtils.cc.

{
  InvalidTimes,
  ValidTimes
};

Function Documentation

DrawLineAndPoints()

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

Definition at line 322 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);
  }
}

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

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 58 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) {
 
        const auto richTrajectoryPoint = dynamic_cast<G4RichTrajectoryPoint*>(aTrajectoryPoint);
        if (richTrajectoryPoint) {
          trajectoryPointPreTime  = richTrajectoryPoint->GetPreStepPointGlobalTime();
          trajectoryPointPostTime = richTrajectoryPoint->GetPostStepPointGlobalTime();
          if (trajectoryPointPostTime > 1000000. * context.GetTimeSliceInterval()) {
            static G4bool warnedTimeExceeded = false;
            if (!warnedTimeExceeded) {
              G4Exception("G4TrajectoryUtils::GetPointsAndTimes", "modeling0128", JustWarning,
                          "Trajectory point times exceed limit (>1000000 time slice)."
                          "\nNormal trajectory will be drawn.");
              warnedTimeExceeded = true;
            }
            validity = InvalidTimes;
          }
        } else {
          static G4bool warnedNoAttValues = false;
          if (!warnedNoAttValues) {
            G4Exception("G4TrajectoryUtils::GetPointsAndTimes", "modeling0127", JustWarning,
                        "Trajectory point times not found. Use G4RichTrajectory:"
                        "\n  /vis/scene/add/trajectories rich");
            warnedNoAttValues = true;
          }
          validity = InvalidTimes;
        }
      }
 
      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;
}

Referenced by DrawLineAndPoints().