| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // Jane Tinslay, John Allison, Joseph Perl Nov 27 // Jane Tinslay, John Allison, Joseph Perl November 2005
28 // 28 //
29 #include "G4TrajectoryDrawerUtils.hh" 29 #include "G4TrajectoryDrawerUtils.hh"
30 #include "G4Colour.hh" 30 #include "G4Colour.hh"
31 #include "G4Polyline.hh" 31 #include "G4Polyline.hh"
32 #include "G4Polymarker.hh" 32 #include "G4Polymarker.hh"
33 #include "G4VTrajectory.hh" 33 #include "G4VTrajectory.hh"
34 #include "G4VTrajectoryPoint.hh" 34 #include "G4VTrajectoryPoint.hh"
35 #include "G4VisAttributes.hh" 35 #include "G4VisAttributes.hh"
36 #include "G4VisTrajContext.hh" 36 #include "G4VisTrajContext.hh"
37 #include "G4VVisManager.hh" 37 #include "G4VVisManager.hh"
38 #include "G4UIcommand.hh" 38 #include "G4UIcommand.hh"
39 #include "G4AttValue.hh" 39 #include "G4AttValue.hh"
40 40
41 #include <utility> <<
42 <<
43 #define G4warn G4cout <<
44 <<
45 namespace G4TrajectoryDrawerUtils { 41 namespace G4TrajectoryDrawerUtils {
46 42
47 enum TimesValidity {InvalidTimes, ValidTimes 43 enum TimesValidity {InvalidTimes, ValidTimes};
48 44
49 TimesValidity GetPointsAndTimes 45 TimesValidity GetPointsAndTimes
50 (const G4VTrajectory& traj, 46 (const G4VTrajectory& traj,
51 const G4VisTrajContext& context, 47 const G4VisTrajContext& context,
52 G4Polyline& trajectoryLine, 48 G4Polyline& trajectoryLine,
53 G4Polymarker& auxiliaryPoints, 49 G4Polymarker& auxiliaryPoints,
54 G4Polymarker& stepPoints, 50 G4Polymarker& stepPoints,
55 std::vector<G4double>& trajectoryLineTimes, 51 std::vector<G4double>& trajectoryLineTimes,
56 std::vector<G4double>& auxiliaryPointTimes, 52 std::vector<G4double>& auxiliaryPointTimes,
57 std::vector<G4double>& stepPointTimes) 53 std::vector<G4double>& stepPointTimes)
58 { 54 {
59 TimesValidity validity = InvalidTimes; 55 TimesValidity validity = InvalidTimes;
60 if (context.GetTimeSliceInterval()) validi 56 if (context.GetTimeSliceInterval()) validity = ValidTimes;
61 57
62 // Memory for last trajectory point positi 58 // Memory for last trajectory point position for auxiliary point
63 // time interpolation algorithm. There ar 59 // time interpolation algorithm. There are no auxiliary points
64 // for the first trajectory point, so its 60 // for the first trajectory point, so its initial value is
65 // immaterial. 61 // immaterial.
66 G4ThreeVector lastTrajectoryPointPosition; 62 G4ThreeVector lastTrajectoryPointPosition;
67 63
68 // Keep positions. Don't store unless fir 64 // Keep positions. Don't store unless first or different.
69 std::vector<G4ThreeVector> positions; 65 std::vector<G4ThreeVector> positions;
70 66
71 for (G4int iPoint=0; iPoint<traj.GetPointE 67 for (G4int iPoint=0; iPoint<traj.GetPointEntries(); iPoint++) {
72 68
73 G4VTrajectoryPoint* aTrajectoryPoint = t 69 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(iPoint);
74 const G4ThreeVector& trajectoryPointPosi 70 const G4ThreeVector& trajectoryPointPosition =
75 aTrajectoryPoint->GetPosition(); 71 aTrajectoryPoint->GetPosition();
76 72
77 // Only store if first or if different 73 // Only store if first or if different
78 if (positions.size() == 0 || 74 if (positions.size() == 0 ||
79 trajectoryPointPosition != positions[posit 75 trajectoryPointPosition != positions[positions.size()-1]) {
80 76
81 // Pre- and Post-Point times from the trajec 77 // Pre- and Post-Point times from the trajectory point...
82 G4double trajectoryPointPreTime = -std::nume 78 G4double trajectoryPointPreTime = -std::numeric_limits<double>::max();
83 G4double trajectoryPointPostTime = std::nume 79 G4double trajectoryPointPostTime = std::numeric_limits<double>::max();
84 80
85 if (context.GetTimeSliceInterval() && validi 81 if (context.GetTimeSliceInterval() && validity == ValidTimes) {
86 82
87 std::vector<G4AttValue>* trajectoryPointAt 83 std::vector<G4AttValue>* trajectoryPointAttValues =
88 aTrajectoryPoint->CreateAttValues(); 84 aTrajectoryPoint->CreateAttValues();
89 if (!trajectoryPointAttValues) { 85 if (!trajectoryPointAttValues) {
90 static G4bool warnedNoAttValues = false; 86 static G4bool warnedNoAttValues = false;
91 if (!warnedNoAttValues) { 87 if (!warnedNoAttValues) {
92 G4warn << << 88 G4cout <<
93 "******************************************* 89 "*************************************************************************"
94 "\n* WARNING: G4TrajectoryDrawerUtils::GetP 90 "\n* WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: no att values."
95 "\n***************************************** 91 "\n*************************************************************************"
96 << G4endl; 92 << G4endl;
97 warnedNoAttValues = true; 93 warnedNoAttValues = true;
98 } 94 }
99 validity = InvalidTimes; 95 validity = InvalidTimes;
100 } else { 96 } else {
101 G4bool foundPreTime = false, foundPostTi 97 G4bool foundPreTime = false, foundPostTime = false;
102 for (std::vector<G4AttValue>::iterator i 98 for (std::vector<G4AttValue>::iterator i =
103 trajectoryPointAttValues->begin(); 99 trajectoryPointAttValues->begin();
104 i != trajectoryPointAttValues->end(); ++i 100 i != trajectoryPointAttValues->end(); ++i) {
105 if (i->GetName() == "PreT") { 101 if (i->GetName() == "PreT") {
106 trajectoryPointPreTime = 102 trajectoryPointPreTime =
107 G4UIcommand::ConvertToDimensionedDouble( 103 G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
108 foundPreTime = true; 104 foundPreTime = true;
109 } 105 }
110 if (i->GetName() == "PostT") { 106 if (i->GetName() == "PostT") {
111 trajectoryPointPostTime = 107 trajectoryPointPostTime =
112 G4UIcommand::ConvertToDimensionedDouble( 108 G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
113 foundPostTime = true; 109 foundPostTime = true;
114 } 110 }
115 } 111 }
116 if (!foundPreTime || !foundPostTime) { 112 if (!foundPreTime || !foundPostTime) {
117 static G4bool warnedTimesNotFound = fa 113 static G4bool warnedTimesNotFound = false;
118 if (!warnedTimesNotFound) { 114 if (!warnedTimesNotFound) {
119 G4warn << << 115 G4cout <<
120 "******************************************* 116 "*************************************************************************"
121 "\n* WARNING: G4TrajectoryDrawerUtils::GetP 117 "\n* WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: times not found."
122 "\n You need to specify \"/vis/scene/add/tra 118 "\n You need to specify \"/vis/scene/add/trajectories rich\""
123 "\n***************************************** 119 "\n*************************************************************************"
124 << G4endl; 120 << G4endl;
125 warnedTimesNotFound = true; 121 warnedTimesNotFound = true;
126 } 122 }
127 validity = InvalidTimes; 123 validity = InvalidTimes;
128 } 124 }
129 } 125 }
130 delete trajectoryPointAttValues; // 126 delete trajectoryPointAttValues; // (Must be deleted after use.)
131 } 127 }
132 128
133 const std::vector<G4ThreeVector>* auxiliarie 129 const std::vector<G4ThreeVector>* auxiliaries
134 = aTrajectoryPoint->GetAuxiliaryPoints(); 130 = aTrajectoryPoint->GetAuxiliaryPoints();
135 if (0 != auxiliaries) { 131 if (0 != auxiliaries) {
136 for (size_t iAux=0; iAux<auxiliaries->size 132 for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
137 const G4ThreeVector& auxPointPosition = 133 const G4ThreeVector& auxPointPosition = (*auxiliaries)[iAux];
138 if (positions.size() == 0 || 134 if (positions.size() == 0 ||
139 auxPointPosition != positions[positions.si 135 auxPointPosition != positions[positions.size()-1]) {
140 // Only store if first or if different 136 // Only store if first or if different
141 positions.push_back(trajectoryPointPos 137 positions.push_back(trajectoryPointPosition);
142 trajectoryLine.push_back(auxPointPosit 138 trajectoryLine.push_back(auxPointPosition);
143 auxiliaryPoints.push_back(auxPointPosi 139 auxiliaryPoints.push_back(auxPointPosition);
144 if (validity == ValidTimes) { 140 if (validity == ValidTimes) {
145 // Interpolate time for auxiliary points.. 141 // Interpolate time for auxiliary points...
146 G4double s1 = 142 G4double s1 =
147 (auxPointPosition - lastTrajectoryPointP 143 (auxPointPosition - lastTrajectoryPointPosition).mag();
148 G4double s2 = 144 G4double s2 =
149 (trajectoryPointPosition - auxPointPosit 145 (trajectoryPointPosition - auxPointPosition).mag();
150 G4double t = trajectoryPointPreTime + 146 G4double t = trajectoryPointPreTime +
151 (trajectoryPointPostTime - trajectoryPoi 147 (trajectoryPointPostTime - trajectoryPointPreTime) *
152 (s1 / (s1 + s2)); 148 (s1 / (s1 + s2));
153 trajectoryLineTimes.push_back(t); 149 trajectoryLineTimes.push_back(t);
154 auxiliaryPointTimes.push_back(t); 150 auxiliaryPointTimes.push_back(t);
155 } 151 }
156 } 152 }
157 } 153 }
158 } 154 }
159 155
160 positions.push_back(trajectoryPointPosition) 156 positions.push_back(trajectoryPointPosition);
161 trajectoryLine.push_back(trajectoryPointPosi 157 trajectoryLine.push_back(trajectoryPointPosition);
162 stepPoints.push_back(trajectoryPointPosition 158 stepPoints.push_back(trajectoryPointPosition);
163 if (validity == ValidTimes) { 159 if (validity == ValidTimes) {
164 trajectoryLineTimes.push_back(trajectoryPo 160 trajectoryLineTimes.push_back(trajectoryPointPostTime);
165 stepPointTimes.push_back(trajectoryPointPo 161 stepPointTimes.push_back(trajectoryPointPostTime);
166 } 162 }
167 lastTrajectoryPointPosition = trajecto 163 lastTrajectoryPointPosition = trajectoryPointPosition;
168 } 164 }
169 } 165 }
170 return validity; 166 return validity;
171 } 167 }
172 168
173 static void SliceLine(G4double timeIncrement 169 static void SliceLine(G4double timeIncrement,
174 G4Polyline& trajectoryLine, 170 G4Polyline& trajectoryLine,
175 std::vector<G4double>& trajectoryLineTim 171 std::vector<G4double>& trajectoryLineTimes)
176 { 172 {
177 // Assumes valid arguments from GetPoints 173 // Assumes valid arguments from GetPoints and GetTimes.
178 174
179 G4Polyline newTrajectoryLine; 175 G4Polyline newTrajectoryLine;
180 std::vector<G4double> newTrajectoryLineTim 176 std::vector<G4double> newTrajectoryLineTimes;
181 177
182 newTrajectoryLine.push_back(trajectoryLine 178 newTrajectoryLine.push_back(trajectoryLine[0]);
183 newTrajectoryLineTimes.push_back(trajector 179 newTrajectoryLineTimes.push_back(trajectoryLineTimes[0]);
184 size_t lineSize = trajectoryLine.size(); 180 size_t lineSize = trajectoryLine.size();
185 if (lineSize > 1) { 181 if (lineSize > 1) {
186 for (size_t i = 1; i < trajectoryLine.si 182 for (size_t i = 1; i < trajectoryLine.size(); ++i) {
187 G4double deltaT = trajectoryLineTimes[i] - t 183 G4double deltaT = trajectoryLineTimes[i] - trajectoryLineTimes[i - 1];
188 if (deltaT > 0.) { 184 if (deltaT > 0.) {
189 G4double practicalTimeIncrement = 185 G4double practicalTimeIncrement =
190 std::max(timeIncrement, deltaT / 100.); 186 std::max(timeIncrement, deltaT / 100.);
191 for (G4double t = 187 for (G4double t =
192 (int(trajectoryLineTimes[i - 1]/practical 188 (int(trajectoryLineTimes[i - 1]/practicalTimeIncrement) + 1) *
193 practicalTimeIncrement; 189 practicalTimeIncrement;
194 t <= trajectoryLineTimes[i]; 190 t <= trajectoryLineTimes[i];
195 t += practicalTimeIncrement) { 191 t += practicalTimeIncrement) {
196 G4ThreeVector pos = trajectoryLine[i - 1 192 G4ThreeVector pos = trajectoryLine[i - 1] +
197 (trajectoryLine[i] - trajectoryLine[i 193 (trajectoryLine[i] - trajectoryLine[i - 1]) *
198 ((t - trajectoryLineTimes[i - 1]) / de 194 ((t - trajectoryLineTimes[i - 1]) / deltaT);
199 newTrajectoryLine.push_back(pos); 195 newTrajectoryLine.push_back(pos);
200 newTrajectoryLineTimes.push_back(t); 196 newTrajectoryLineTimes.push_back(t);
201 } 197 }
202 } 198 }
203 newTrajectoryLine.push_back(trajectoryLine[i 199 newTrajectoryLine.push_back(trajectoryLine[i]);
204 newTrajectoryLineTimes.push_back(trajectoryL 200 newTrajectoryLineTimes.push_back(trajectoryLineTimes[i]);
205 } 201 }
206 } 202 }
207 203
208 trajectoryLine = std::move(newTrajectoryLi << 204 trajectoryLine = newTrajectoryLine;
209 trajectoryLineTimes = std::move(newTraject << 205 trajectoryLineTimes = newTrajectoryLineTimes;
210 } 206 }
211 207
212 static void DrawWithoutTime(const G4VisTrajC 208 static void DrawWithoutTime(const G4VisTrajContext& myContext,
213 G4Polyline& trajectoryLine, 209 G4Polyline& trajectoryLine,
214 G4Polymarker& auxiliaryPoints, 210 G4Polymarker& auxiliaryPoints,
215 G4Polymarker& stepPoints) 211 G4Polymarker& stepPoints)
216 { 212 {
217 // Draw without time slice information 213 // Draw without time slice information
218 214
219 G4VVisManager* pVVisManager = G4VVisManage 215 G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
220 if (0 == pVVisManager) return; 216 if (0 == pVVisManager) return;
221 217
222 if (myContext.GetDrawLine() && myContext.G 218 if (myContext.GetDrawLine() && myContext.GetLineVisible()) {
223 G4VisAttributes trajectoryLineAttribs(my 219 G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
224 trajectoryLineAttribs.SetLineWidth(myCon 220 trajectoryLineAttribs.SetLineWidth(myContext.GetLineWidth());
225 trajectoryLine.SetVisAttributes(&traject 221 trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
226 222
227 pVVisManager->Draw(trajectoryLine); 223 pVVisManager->Draw(trajectoryLine);
228 } 224 }
229 225
230 if (myContext.GetDrawAuxPts() && myContext 226 if (myContext.GetDrawAuxPts() && myContext.GetAuxPtsVisible()
231 && (auxiliaryPoints.size() > 0)) { 227 && (auxiliaryPoints.size() > 0)) {
232 auxiliaryPoints.SetMarkerType(myContext. 228 auxiliaryPoints.SetMarkerType(myContext.GetAuxPtsType());
233 auxiliaryPoints.SetSize(myContext.GetAux 229 auxiliaryPoints.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
234 auxiliaryPoints.SetFillStyle(myContext.G 230 auxiliaryPoints.SetFillStyle(myContext.GetAuxPtsFillStyle());
235 231
236 G4VisAttributes auxiliaryPointsAttribs(m 232 G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());
237 auxiliaryPoints.SetVisAttributes(&auxili 233 auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
238 234
239 pVVisManager->Draw(auxiliaryPoints); 235 pVVisManager->Draw(auxiliaryPoints);
240 } 236 }
241 237
242 if (myContext.GetDrawStepPts() && myContex 238 if (myContext.GetDrawStepPts() && myContext.GetStepPtsVisible()
243 && (stepPoints.size() > 0)) { 239 && (stepPoints.size() > 0)) {
244 stepPoints.SetMarkerType(myContext.GetSt 240 stepPoints.SetMarkerType(myContext.GetStepPtsType());
245 stepPoints.SetSize(myContext.GetStepPtsS 241 stepPoints.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
246 stepPoints.SetFillStyle(myContext.GetSte 242 stepPoints.SetFillStyle(myContext.GetStepPtsFillStyle());
247 243
248 G4VisAttributes stepPointsAttribs(myCont 244 G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
249 stepPoints.SetVisAttributes(&stepPointsA 245 stepPoints.SetVisAttributes(&stepPointsAttribs);
250 246
251 pVVisManager->Draw(stepPoints); 247 pVVisManager->Draw(stepPoints);
252 } 248 }
253 } 249 }
254 250
255 static void DrawWithTime(const G4VisTrajCont 251 static void DrawWithTime(const G4VisTrajContext& myContext,
256 G4Polyline& trajectoryLine, 252 G4Polyline& trajectoryLine,
257 G4Polymarker& auxiliaryPoints, 253 G4Polymarker& auxiliaryPoints,
258 G4Polymarker& stepPoints, 254 G4Polymarker& stepPoints,
259 std::vector<G4double>& trajectoryLine 255 std::vector<G4double>& trajectoryLineTimes,
260 std::vector<G4double>& auxiliaryPoint 256 std::vector<G4double>& auxiliaryPointTimes,
261 std::vector<G4double>& stepPointTimes 257 std::vector<G4double>& stepPointTimes)
262 { 258 {
263 // Draw with time slice information 259 // Draw with time slice information
264 260
265 G4VVisManager* pVVisManager = G4VVisManage 261 G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
266 if (0 == pVVisManager) return; 262 if (0 == pVVisManager) return;
267 263
268 if (myContext.GetDrawLine() && myContext.G 264 if (myContext.GetDrawLine() && myContext.GetLineVisible()) {
269 G4VisAttributes trajectoryLineAttribs(my 265 G4VisAttributes trajectoryLineAttribs(myContext.GetLineColour());
270 trajectoryLineAttribs.SetLineWidth(myCon 266 trajectoryLineAttribs.SetLineWidth(myContext.GetLineWidth());
271 267
272 for (size_t i = 1; i < trajectoryLine.si 268 for (size_t i = 1; i < trajectoryLine.size(); ++i ) {
273 G4Polyline slice; 269 G4Polyline slice;
274 slice.push_back(trajectoryLine[i -1]); 270 slice.push_back(trajectoryLine[i -1]);
275 slice.push_back(trajectoryLine[i]); 271 slice.push_back(trajectoryLine[i]);
276 trajectoryLineAttribs.SetStartTime(trajector 272 trajectoryLineAttribs.SetStartTime(trajectoryLineTimes[i - 1]);
277 trajectoryLineAttribs.SetEndTime(trajectoryL 273 trajectoryLineAttribs.SetEndTime(trajectoryLineTimes[i]);
278 slice.SetVisAttributes(&trajectoryLineAttrib 274 slice.SetVisAttributes(&trajectoryLineAttribs);
279 pVVisManager->Draw(slice); 275 pVVisManager->Draw(slice);
280 } 276 }
281 } 277 }
282 278
283 if (myContext.GetDrawAuxPts() && myContext 279 if (myContext.GetDrawAuxPts() && myContext.GetAuxPtsVisible()
284 && (auxiliaryPoints.size() > 0)) { 280 && (auxiliaryPoints.size() > 0)) {
285 G4VisAttributes auxiliaryPointsAttribs(m 281 G4VisAttributes auxiliaryPointsAttribs(myContext.GetAuxPtsColour());
286 282
287 for (size_t i = 0; i < auxiliaryPoints.s 283 for (size_t i = 0; i < auxiliaryPoints.size(); ++i ) {
288 G4Polymarker point; 284 G4Polymarker point;
289 point.push_back(auxiliaryPoints[i]); 285 point.push_back(auxiliaryPoints[i]);
290 point.SetMarkerType(myContext.GetAuxPtsType( 286 point.SetMarkerType(myContext.GetAuxPtsType());
291 point.SetSize(myContext.GetAuxPtsSizeType(), 287 point.SetSize(myContext.GetAuxPtsSizeType(), myContext.GetAuxPtsSize());
292 point.SetFillStyle(myContext.GetAuxPtsFillSt 288 point.SetFillStyle(myContext.GetAuxPtsFillStyle());
293 auxiliaryPointsAttribs.SetStartTime(auxiliar 289 auxiliaryPointsAttribs.SetStartTime(auxiliaryPointTimes[i]);
294 auxiliaryPointsAttribs.SetEndTime(auxiliaryP 290 auxiliaryPointsAttribs.SetEndTime(auxiliaryPointTimes[i]);
295 point.SetVisAttributes(&auxiliaryPointsAttri 291 point.SetVisAttributes(&auxiliaryPointsAttribs);
296 pVVisManager->Draw(point); 292 pVVisManager->Draw(point);
297 } 293 }
298 } 294 }
299 295
300 if (myContext.GetDrawStepPts() && myContex 296 if (myContext.GetDrawStepPts() && myContext.GetStepPtsVisible()
301 && (stepPoints.size() > 0)) { 297 && (stepPoints.size() > 0)) {
302 G4VisAttributes stepPointsAttribs(myCont 298 G4VisAttributes stepPointsAttribs(myContext.GetStepPtsColour());
303 299
304 for (size_t i = 0; i < stepPoints.size() 300 for (size_t i = 0; i < stepPoints.size(); ++i ) {
305 G4Polymarker point; 301 G4Polymarker point;
306 point.push_back(stepPoints[i]); 302 point.push_back(stepPoints[i]);
307 point.SetMarkerType(myContext.GetStepPtsType 303 point.SetMarkerType(myContext.GetStepPtsType());
308 point.SetSize(myContext.GetStepPtsSizeType() 304 point.SetSize(myContext.GetStepPtsSizeType(), myContext.GetStepPtsSize());
309 point.SetFillStyle(myContext.GetStepPtsFillS 305 point.SetFillStyle(myContext.GetStepPtsFillStyle());
310 stepPointsAttribs.SetStartTime(stepPointTime 306 stepPointsAttribs.SetStartTime(stepPointTimes[i]);
311 stepPointsAttribs.SetEndTime(stepPointTimes[ 307 stepPointsAttribs.SetEndTime(stepPointTimes[i]);
312 point.SetVisAttributes(&stepPointsAttribs); 308 point.SetVisAttributes(&stepPointsAttribs);
313 pVVisManager->Draw(point); 309 pVVisManager->Draw(point);
314 } 310 }
315 } 311 }
316 } 312 }
317 313
318 void DrawLineAndPoints(const G4VTrajectory& 314 void DrawLineAndPoints(const G4VTrajectory& traj, const G4VisTrajContext& context)
319 { 315 {
320 // Return if don't need to do anything 316 // Return if don't need to do anything
321 if (!context.GetDrawLine() && !context.Get 317 if (!context.GetDrawLine() && !context.GetDrawAuxPts() && !context.GetDrawStepPts()) return;
322 318
323 // Get points and times (times are returne 319 // Get points and times (times are returned only if time-slicing
324 // is requested). 320 // is requested).
325 G4Polyline trajectoryLine; 321 G4Polyline trajectoryLine;
326 G4Polymarker stepPoints; 322 G4Polymarker stepPoints;
327 G4Polymarker auxiliaryPoints; 323 G4Polymarker auxiliaryPoints;
328 std::vector<G4double> trajectoryLineTimes; 324 std::vector<G4double> trajectoryLineTimes;
329 std::vector<G4double> stepPointTimes; 325 std::vector<G4double> stepPointTimes;
330 std::vector<G4double> auxiliaryPointTimes; 326 std::vector<G4double> auxiliaryPointTimes;
331 327
332 TimesValidity validity = GetPointsAndTimes 328 TimesValidity validity = GetPointsAndTimes
333 (traj, context, 329 (traj, context,
334 trajectoryLine, auxiliaryPoints, stepPo 330 trajectoryLine, auxiliaryPoints, stepPoints,
335 trajectoryLineTimes, auxiliaryPointTime 331 trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
336 332
337 if (validity == ValidTimes) { 333 if (validity == ValidTimes) {
338 334
339 SliceLine(context.GetTimeSliceInterval() 335 SliceLine(context.GetTimeSliceInterval(),
340 trajectoryLine, trajectoryLineTimes); 336 trajectoryLine, trajectoryLineTimes);
341 337
342 DrawWithTime(context, 338 DrawWithTime(context,
343 trajectoryLine, auxiliaryPoints, stepPo 339 trajectoryLine, auxiliaryPoints, stepPoints,
344 trajectoryLineTimes, auxiliaryPointTime 340 trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
345 341
346 } else { 342 } else {
347 343
348 DrawWithoutTime(context, trajectoryLine, 344 DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
349 345
350 } 346 }
351 } 347 }
352 } 348 }
353 349