| 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 // 27 //
28 // 28 //
29 // 29 //
30 30
31 31
32 #include "G4TheRayTracer.hh" 32 #include "G4TheRayTracer.hh"
33 #include "G4SystemOfUnits.hh" 33 #include "G4SystemOfUnits.hh"
34 #include "G4EventManager.hh" 34 #include "G4EventManager.hh"
35 #include "G4RTMessenger.hh" 35 #include "G4RTMessenger.hh"
36 #include "G4RayShooter.hh" 36 #include "G4RayShooter.hh"
37 #include "G4VFigureFileMaker.hh" 37 #include "G4VFigureFileMaker.hh"
38 #include "G4RTTrackingAction.hh" 38 #include "G4RTTrackingAction.hh"
39 #include "G4RTSteppingAction.hh" 39 #include "G4RTSteppingAction.hh"
40 #include "G4RayTrajectory.hh" 40 #include "G4RayTrajectory.hh"
41 #include "G4RayTrajectoryPoint.hh" 41 #include "G4RayTrajectoryPoint.hh"
42 #include "G4RTJpegMaker.hh" 42 #include "G4RTJpegMaker.hh"
43 #include "G4RTSimpleScanner.hh" 43 #include "G4RTSimpleScanner.hh"
44 #include "G4GeometryManager.hh" 44 #include "G4GeometryManager.hh"
45 #include "G4SDManager.hh" 45 #include "G4SDManager.hh"
46 #include "G4StateManager.hh" 46 #include "G4StateManager.hh"
47 #include "G4Event.hh" 47 #include "G4Event.hh"
48 #include "G4TrajectoryContainer.hh" 48 #include "G4TrajectoryContainer.hh"
49 #include "G4Colour.hh" 49 #include "G4Colour.hh"
50 #include "G4VisAttributes.hh" 50 #include "G4VisAttributes.hh"
51 #include "G4UImanager.hh" 51 #include "G4UImanager.hh"
52 #include "G4TransportationManager.hh" 52 #include "G4TransportationManager.hh"
53 #include "G4RegionStore.hh" 53 #include "G4RegionStore.hh"
54 #include "G4ProductionCutsTable.hh" 54 #include "G4ProductionCutsTable.hh"
55 #include "G4VVisManager.hh" 55 #include "G4VVisManager.hh"
56 56
57 #define G4warn G4cout <<
58 <<
59 G4VFigureFileMaker * G4TheRayTracer::theFigMak 57 G4VFigureFileMaker * G4TheRayTracer::theFigMaker = 0;
60 G4VRTScanner * G4TheRayTracer::theScanner = 0; 58 G4VRTScanner * G4TheRayTracer::theScanner = 0;
61 59
62 G4TheRayTracer::G4TheRayTracer(G4VFigureFileMa 60 G4TheRayTracer::G4TheRayTracer(G4VFigureFileMaker* figMaker,
63 G4VRTScanner* scanner) 61 G4VRTScanner* scanner)
64 { 62 {
65 theFigMaker = figMaker; 63 theFigMaker = figMaker;
66 if(!theFigMaker) theFigMaker = new G4RTJpegM 64 if(!theFigMaker) theFigMaker = new G4RTJpegMaker;
67 theScanner = scanner; 65 theScanner = scanner;
68 if(!theScanner) theScanner = new G4RTSimpleS 66 if(!theScanner) theScanner = new G4RTSimpleScanner;
69 theRayShooter = new G4RayShooter(); 67 theRayShooter = new G4RayShooter();
70 theUserEventAction = 0; 68 theUserEventAction = 0;
71 theUserStackingAction = 0; 69 theUserStackingAction = 0;
72 theUserTrackingAction = 0; 70 theUserTrackingAction = 0;
73 theUserSteppingAction = 0; 71 theUserSteppingAction = 0;
74 theRayTracerEventAction = 0; 72 theRayTracerEventAction = 0;
75 theRayTracerStackingAction = 0; 73 theRayTracerStackingAction = 0;
76 theRayTracerTrackingAction = 0; 74 theRayTracerTrackingAction = 0;
77 theRayTracerSteppingAction = 0; 75 theRayTracerSteppingAction = 0;
78 colorR = 0; 76 colorR = 0;
79 colorG = 0; 77 colorG = 0;
80 colorB = 0; 78 colorB = 0;
81 79
82 theMessenger = G4RTMessenger::GetInstance(th 80 theMessenger = G4RTMessenger::GetInstance(this);
83 theEventManager = G4EventManager::GetEventMa 81 theEventManager = G4EventManager::GetEventManager();
84 82
85 nColumn = 640; 83 nColumn = 640;
86 nRow = 640; 84 nRow = 640;
87 85
88 eyePosition = G4ThreeVector(1.*m,1.*m,1.*m); 86 eyePosition = G4ThreeVector(1.*m,1.*m,1.*m);
89 targetPosition = G4ThreeVector(0.,0.,0.); 87 targetPosition = G4ThreeVector(0.,0.,0.);
90 lightDirection = G4ThreeVector(-0.1,-0.2,-0. 88 lightDirection = G4ThreeVector(-0.1,-0.2,-0.3).unit();
91 up = G4ThreeVector(0,1,0); 89 up = G4ThreeVector(0,1,0);
92 viewSpan = 5.0*deg; 90 viewSpan = 5.0*deg;
93 headAngle = 0.; 91 headAngle = 0.;
94 attenuationLength = 1.0*m; 92 attenuationLength = 1.0*m;
95 93
96 distortionOn = false; 94 distortionOn = false;
97 antialiasingOn = false; 95 antialiasingOn = false;
98 96
99 backgroundColour = G4Colour(1.,1.,1.); 97 backgroundColour = G4Colour(1.,1.,1.);
100 } 98 }
101 99
102 G4TheRayTracer::~G4TheRayTracer() 100 G4TheRayTracer::~G4TheRayTracer()
103 { 101 {
104 delete theRayShooter; 102 delete theRayShooter;
105 if(theRayTracerTrackingAction) delete theRay 103 if(theRayTracerTrackingAction) delete theRayTracerTrackingAction;
106 if(theRayTracerSteppingAction) delete theRay 104 if(theRayTracerSteppingAction) delete theRayTracerSteppingAction;
107 delete theMessenger; 105 delete theMessenger;
108 delete theScanner; 106 delete theScanner;
109 delete theFigMaker; 107 delete theFigMaker;
110 } 108 }
111 109
112 void G4TheRayTracer::Trace(const G4String& fil 110 void G4TheRayTracer::Trace(const G4String& fileName)
113 { 111 {
114 G4StateManager* theStateMan = G4StateManager 112 G4StateManager* theStateMan = G4StateManager::GetStateManager();
115 G4ApplicationState currentState = theStateMa 113 G4ApplicationState currentState = theStateMan->GetCurrentState();
116 if(currentState!=G4State_Idle) 114 if(currentState!=G4State_Idle)
117 { 115 {
118 G4warn << "Illegal application state - Tra << 116 G4cerr << "Illegal application state - Trace() ignored." << G4endl;
119 return; 117 return;
120 } 118 }
121 119
122 if(!theFigMaker) 120 if(!theFigMaker)
123 { 121 {
124 G4warn << "Figure file maker class is not << 122 G4cerr << "Figure file maker class is not specified - Trace() ignored." << G4endl;
125 return; 123 return;
126 } 124 }
127 125
128 G4UImanager* UI = G4UImanager::GetUIpointer( 126 G4UImanager* UI = G4UImanager::GetUIpointer();
129 G4int storeTrajectory = UI->GetCurrentIntVal 127 G4int storeTrajectory = UI->GetCurrentIntValue("/tracking/storeTrajectory");
130 if(storeTrajectory==0) UI->ApplyCommand("/tr 128 if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 1");
131 129
132 130
133 G4ThreeVector tmpVec = targetPosition - eyeP 131 G4ThreeVector tmpVec = targetPosition - eyePosition;
134 eyeDirection = tmpVec.unit(); 132 eyeDirection = tmpVec.unit();
135 colorR = new unsigned char[nColumn*nRow]; 133 colorR = new unsigned char[nColumn*nRow];
136 colorG = new unsigned char[nColumn*nRow]; 134 colorG = new unsigned char[nColumn*nRow];
137 colorB = new unsigned char[nColumn*nRow]; 135 colorB = new unsigned char[nColumn*nRow];
138 136
139 StoreUserActions(); 137 StoreUserActions();
140 G4bool succeeded = CreateBitMap(); 138 G4bool succeeded = CreateBitMap();
141 if(succeeded) 139 if(succeeded)
142 { CreateFigureFile(fileName); } 140 { CreateFigureFile(fileName); }
143 else 141 else
144 { G4warn << "Could not create figure file" < << 142 { G4cerr << "Could not create figure file" << G4endl;
145 G4warn << "You might set the eye position << 143 G4cerr << "You might set the eye position outside of the world volume" << G4endl; }
146 RestoreUserActions(); 144 RestoreUserActions();
147 145
148 if(storeTrajectory==0) UI->ApplyCommand("/tr 146 if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 0");
149 147
150 delete [] colorR; 148 delete [] colorR;
151 delete [] colorG; 149 delete [] colorG;
152 delete [] colorB; 150 delete [] colorB;
153 } 151 }
154 152
155 void G4TheRayTracer::StoreUserActions() 153 void G4TheRayTracer::StoreUserActions()
156 { 154 {
157 theUserEventAction = theEventManager->GetUse 155 theUserEventAction = theEventManager->GetUserEventAction();
158 theUserStackingAction = theEventManager->Get 156 theUserStackingAction = theEventManager->GetUserStackingAction();
159 theUserTrackingAction = theEventManager->Get 157 theUserTrackingAction = theEventManager->GetUserTrackingAction();
160 theUserSteppingAction = theEventManager->Get 158 theUserSteppingAction = theEventManager->GetUserSteppingAction();
161 159
162 if(!theRayTracerTrackingAction) theRayTracer 160 if(!theRayTracerTrackingAction) theRayTracerTrackingAction = new G4RTTrackingAction();
163 if(!theRayTracerSteppingAction) theRayTracer 161 if(!theRayTracerSteppingAction) theRayTracerSteppingAction = new G4RTSteppingAction();
164 162
165 theEventManager->SetUserAction(theRayTracerE 163 theEventManager->SetUserAction(theRayTracerEventAction);
166 theEventManager->SetUserAction(theRayTracerS 164 theEventManager->SetUserAction(theRayTracerStackingAction);
167 theEventManager->SetUserAction(theRayTracerT 165 theEventManager->SetUserAction(theRayTracerTrackingAction);
168 theEventManager->SetUserAction(theRayTracerS 166 theEventManager->SetUserAction(theRayTracerSteppingAction);
169 167
170 G4SDManager* theSDMan = G4SDManager::GetSDMp 168 G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
171 if(theSDMan) 169 if(theSDMan)
172 { theSDMan->Activate("/",false); } 170 { theSDMan->Activate("/",false); }
173 171
174 G4GeometryManager* theGeomMan = G4GeometryMa 172 G4GeometryManager* theGeomMan = G4GeometryManager::GetInstance();
175 theGeomMan->OpenGeometry(); 173 theGeomMan->OpenGeometry();
176 theGeomMan->CloseGeometry(true); 174 theGeomMan->CloseGeometry(true);
177 } 175 }
178 176
179 void G4TheRayTracer::RestoreUserActions() 177 void G4TheRayTracer::RestoreUserActions()
180 { 178 {
181 theEventManager->SetUserAction(theUserEventA 179 theEventManager->SetUserAction(theUserEventAction);
182 theEventManager->SetUserAction(theUserStacki 180 theEventManager->SetUserAction(theUserStackingAction);
183 theEventManager->SetUserAction(theUserTracki 181 theEventManager->SetUserAction(theUserTrackingAction);
184 theEventManager->SetUserAction(theUserSteppi 182 theEventManager->SetUserAction(theUserSteppingAction);
185 183
186 G4SDManager* theSDMan = G4SDManager::GetSDMp 184 G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
187 if(theSDMan) 185 if(theSDMan)
188 { theSDMan->Activate("/",true); } 186 { theSDMan->Activate("/",true); }
189 } 187 }
190 188
191 #include "G4ProcessManager.hh" 189 #include "G4ProcessManager.hh"
192 #include "G4ProcessVector.hh" 190 #include "G4ProcessVector.hh"
193 #include "G4Geantino.hh" 191 #include "G4Geantino.hh"
194 192
195 G4bool G4TheRayTracer::CreateBitMap() 193 G4bool G4TheRayTracer::CreateBitMap()
196 { 194 {
197 G4int iEvent = 0; 195 G4int iEvent = 0;
198 G4double stepAngle = viewSpan/100.; 196 G4double stepAngle = viewSpan/100.;
199 G4double viewSpanX = stepAngle*nColumn; 197 G4double viewSpanX = stepAngle*nColumn;
200 G4double viewSpanY = stepAngle*nRow; 198 G4double viewSpanY = stepAngle*nRow;
201 G4bool succeeded; 199 G4bool succeeded;
202 200
203 G4VVisManager* visMan = G4VVisManager::GetCo 201 G4VVisManager* visMan = G4VVisManager::GetConcreteInstance();
204 visMan->IgnoreStateChanges(true); 202 visMan->IgnoreStateChanges(true);
205 203
206 // Confirm process(es) of Geantino is initiali 204 // Confirm process(es) of Geantino is initialized
207 G4VPhysicalVolume* pWorld = 205 G4VPhysicalVolume* pWorld =
208 G4TransportationManager::GetTransportationMa 206 G4TransportationManager::GetTransportationManager()->
209 GetNavigatorForTracking()->GetWorldVolume(); 207 GetNavigatorForTracking()->GetWorldVolume();
210 G4RegionStore::GetInstance()->UpdateMaterial 208 G4RegionStore::GetInstance()->UpdateMaterialList(pWorld);
211 G4ProductionCutsTable::GetProductionCutsTabl 209 G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(pWorld);
212 G4ProcessVector* pVector 210 G4ProcessVector* pVector
213 = G4Geantino::GeantinoDefinition()->GetPro 211 = G4Geantino::GeantinoDefinition()->GetProcessManager()->GetProcessList();
214 for (G4int j=0; j < (G4int)pVector->size(); << 212 for (std::size_t j=0; j < pVector->size(); ++j) {
215 (*pVector)[j]->BuildPhysicsTable(*(G4Gea 213 (*pVector)[j]->BuildPhysicsTable(*(G4Geantino::GeantinoDefinition()));
216 } 214 }
217 215
218 // Close geometry and set the application stat 216 // Close geometry and set the application state
219 G4GeometryManager* geomManager = G4GeometryM 217 G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
220 geomManager->OpenGeometry(); 218 geomManager->OpenGeometry();
221 geomManager->CloseGeometry(1,0); 219 geomManager->CloseGeometry(1,0);
222 220
223 G4ThreeVector center(0,0,0); 221 G4ThreeVector center(0,0,0);
224 G4Navigator* navigator = 222 G4Navigator* navigator =
225 G4TransportationManager::GetTransportati 223 G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
226 navigator->LocateGlobalPointAndSetup(center, 224 navigator->LocateGlobalPointAndSetup(center,0,false);
227 225
228 G4StateManager* theStateMan = G4StateManager 226 G4StateManager* theStateMan = G4StateManager::GetStateManager();
229 theStateMan->SetNewState(G4State_GeomClosed) 227 theStateMan->SetNewState(G4State_GeomClosed);
230 228
231 // Event loop 229 // Event loop
232 theScanner->Initialize(nRow,nColumn); 230 theScanner->Initialize(nRow,nColumn);
233 G4int iRow, iColumn; 231 G4int iRow, iColumn;
234 while (theScanner->Coords(iRow,iColumn)) { 232 while (theScanner->Coords(iRow,iColumn)) {
235 G4int iCoord = iRow * nColumn + iColumn; 233 G4int iCoord = iRow * nColumn + iColumn;
236 G4double dRow = 0, dColumn = 0; // Anti 234 G4double dRow = 0, dColumn = 0; // Antialiasing increments.
237 G4Event* anEvent = new G4Event(iEvent++) 235 G4Event* anEvent = new G4Event(iEvent++);
238 G4double angleX = -(viewSpanX/2. - (iCol 236 G4double angleX = -(viewSpanX/2. - (iColumn+dColumn)*stepAngle);
239 G4double angleY = viewSpanY/2. - (iRow+d 237 G4double angleY = viewSpanY/2. - (iRow+dRow)*stepAngle;
240 G4ThreeVector rayDirection; 238 G4ThreeVector rayDirection;
241 if(distortionOn) 239 if(distortionOn)
242 { 240 {
243 rayDirection = G4ThreeVector(-std::tan(angle 241 rayDirection = G4ThreeVector(-std::tan(angleX)/std::cos(angleY),std::tan(angleY)/std::cos(angleX),1.0);
244 } 242 }
245 else 243 else
246 { 244 {
247 rayDirection = G4ThreeVector(-std::tan(angle 245 rayDirection = G4ThreeVector(-std::tan(angleX),std::tan(angleY),1.0);
248 } 246 }
249 G4double cp = std::cos(eyeDirection.phi( 247 G4double cp = std::cos(eyeDirection.phi());
250 G4double sp = std::sqrt(1.-cp*cp); 248 G4double sp = std::sqrt(1.-cp*cp);
251 G4double ct = std::cos(eyeDirection.thet 249 G4double ct = std::cos(eyeDirection.theta());
252 G4double st = std::sqrt(1.-ct*ct); 250 G4double st = std::sqrt(1.-ct*ct);
253 G4double gamma = std::atan2(ct*cp*up.x() 251 G4double gamma = std::atan2(ct*cp*up.x()+ct*sp*up.y()-st*up.z(), -sp*up.x()+cp*up.y());
254 rayDirection.rotateZ(-gamma); 252 rayDirection.rotateZ(-gamma);
255 rayDirection.rotateZ(headAngle); 253 rayDirection.rotateZ(headAngle);
256 rayDirection.rotateUz(eyeDirection); 254 rayDirection.rotateUz(eyeDirection);
257 G4ThreeVector rayPosition(eyePosition); 255 G4ThreeVector rayPosition(eyePosition);
258 G4bool interceptable = true; 256 G4bool interceptable = true;
259 // Check if rayPosition is in the world. 257 // Check if rayPosition is in the world.
260 EInside whereisit = 258 EInside whereisit =
261 pWorld->GetLogicalVolume()->GetSolid()->Insi 259 pWorld->GetLogicalVolume()->GetSolid()->Inside(rayPosition);
262 if (whereisit != kInside) { 260 if (whereisit != kInside) {
263 // It's outside the world, so move it inside 261 // It's outside the world, so move it inside.
264 G4double outsideDistance = 262 G4double outsideDistance =
265 pWorld->GetLogicalVolume()->GetSolid()-> 263 pWorld->GetLogicalVolume()->GetSolid()->
266 DistanceToIn(rayPosition,rayDirection); 264 DistanceToIn(rayPosition,rayDirection);
267 if (outsideDistance != kInfinity) { 265 if (outsideDistance != kInfinity) {
268 // Borrowing from geometry, where 1e-8 < e 266 // Borrowing from geometry, where 1e-8 < epsilon < 1e-3, in
269 // absolute/internal length units, is used 267 // absolute/internal length units, is used for ensuring good
270 // behaviour, choose to add 0.001 to ensur 268 // behaviour, choose to add 0.001 to ensure rayPosition is
271 // definitely inside the world volume (JA 269 // definitely inside the world volume (JA 16/9/2005)...
272 rayPosition = rayPosition+(outsideDistance 270 rayPosition = rayPosition+(outsideDistance+0.001)*rayDirection;
273 } 271 }
274 else { 272 else {
275 interceptable = false; 273 interceptable = false;
276 } 274 }
277 } 275 }
278 if (interceptable) { 276 if (interceptable) {
279 theRayShooter->Shoot(anEvent,rayPosition,ray 277 theRayShooter->Shoot(anEvent,rayPosition,rayDirection.unit());
280 theEventManager->ProcessOneEvent(anEvent); 278 theEventManager->ProcessOneEvent(anEvent);
281 succeeded = GenerateColour(anEvent); 279 succeeded = GenerateColour(anEvent);
282 colorR[iCoord] = (unsigned char)(G4int(255*r 280 colorR[iCoord] = (unsigned char)(G4int(255*rayColour.GetRed()));
283 colorG[iCoord] = (unsigned char)(G4int(255*r 281 colorG[iCoord] = (unsigned char)(G4int(255*rayColour.GetGreen()));
284 colorB[iCoord] = (unsigned char)(G4int(255*r 282 colorB[iCoord] = (unsigned char)(G4int(255*rayColour.GetBlue()));
285 } else { // Ray does not intercept worl 283 } else { // Ray does not intercept world at all.
286 // Store background colour... 284 // Store background colour...
287 colorR[iCoord] = (unsigned char)(G4int(255*b 285 colorR[iCoord] = (unsigned char)(G4int(255*backgroundColour.GetRed()));
288 colorG[iCoord] = (unsigned char)(G4int(255*b 286 colorG[iCoord] = (unsigned char)(G4int(255*backgroundColour.GetGreen()));
289 colorB[iCoord] = (unsigned char)(G4int(255*b 287 colorB[iCoord] = (unsigned char)(G4int(255*backgroundColour.GetBlue()));
290 succeeded = true; 288 succeeded = true;
291 } 289 }
292 290
293 theScanner->Draw(colorR[iCoord],colorG[i 291 theScanner->Draw(colorR[iCoord],colorG[iCoord],colorB[iCoord]);
294 292
295 delete anEvent; 293 delete anEvent;
296 if(!succeeded) return false; 294 if(!succeeded) return false;
297 } 295 }
298 296
299 theStateMan->SetNewState(G4State_Idle); 297 theStateMan->SetNewState(G4State_Idle);
300 visMan->IgnoreStateChanges(false); 298 visMan->IgnoreStateChanges(false);
301 return true; 299 return true;
302 } 300 }
303 301
304 void G4TheRayTracer::CreateFigureFile(const G4 302 void G4TheRayTracer::CreateFigureFile(const G4String& fileName)
305 { 303 {
306 //G4cout << nColumn << " " << nRow << G4endl 304 //G4cout << nColumn << " " << nRow << G4endl;
307 theFigMaker->CreateFigureFile(fileName,nColu 305 theFigMaker->CreateFigureFile(fileName,nColumn,nRow,colorR,colorG,colorB);
308 } 306 }
309 307
310 G4bool G4TheRayTracer::GenerateColour(G4Event* 308 G4bool G4TheRayTracer::GenerateColour(G4Event* anEvent)
311 { 309 {
312 G4TrajectoryContainer * trajectoryContainer 310 G4TrajectoryContainer * trajectoryContainer = anEvent->GetTrajectoryContainer();
313 311
314 G4RayTrajectory* trajectory = (G4RayTrajecto 312 G4RayTrajectory* trajectory = (G4RayTrajectory*)( (*trajectoryContainer)[0] );
315 if(!trajectory) return false; 313 if(!trajectory) return false;
316 314
317 G4int nPoint = trajectory->GetPointEntries() 315 G4int nPoint = trajectory->GetPointEntries();
318 if(nPoint==0) return false; 316 if(nPoint==0) return false;
319 317
320 G4Colour initialColour(backgroundColour); 318 G4Colour initialColour(backgroundColour);
321 if( trajectory->GetPointC(nPoint-1)->GetPost 319 if( trajectory->GetPointC(nPoint-1)->GetPostStepAtt() )
322 { initialColour = GetSurfaceColour(trajector 320 { initialColour = GetSurfaceColour(trajectory->GetPointC(nPoint-1)); }
323 rayColour = Attenuate(trajectory->GetPointC( 321 rayColour = Attenuate(trajectory->GetPointC(nPoint-1),initialColour);
324 322
325 for(G4int i=nPoint-2;i>=0;--i) 323 for(G4int i=nPoint-2;i>=0;--i)
326 { 324 {
327 G4Colour surfaceColour = GetSurfaceColour( 325 G4Colour surfaceColour = GetSurfaceColour(trajectory->GetPointC(i));
328 G4double weight = 1.0 - surfaceColour.GetA 326 G4double weight = 1.0 - surfaceColour.GetAlpha();
329 G4Colour mixedColour = GetMixedColour(rayC 327 G4Colour mixedColour = GetMixedColour(rayColour,surfaceColour,weight);
330 rayColour = Attenuate(trajectory->GetPoint 328 rayColour = Attenuate(trajectory->GetPointC(i),mixedColour);
331 } 329 }
332 330
333 return true; 331 return true;
334 } 332 }
335 333
336 G4Colour G4TheRayTracer::GetMixedColour 334 G4Colour G4TheRayTracer::GetMixedColour
337 (const G4Colour& surfCol,const G4Colour& trans 335 (const G4Colour& surfCol,const G4Colour& transCol,G4double weight)
338 { 336 {
339 G4double red = weight*surfCol.GetRed() + ( 337 G4double red = weight*surfCol.GetRed() + (1.-weight)*transCol.GetRed();
340 G4double green = weight*surfCol.GetGreen() + 338 G4double green = weight*surfCol.GetGreen() + (1.-weight)*transCol.GetGreen();
341 G4double blue = weight*surfCol.GetBlue() + 339 G4double blue = weight*surfCol.GetBlue() + (1.-weight)*transCol.GetBlue();
342 G4double alpha = weight*surfCol.GetAlpha() + 340 G4double alpha = weight*surfCol.GetAlpha() + (1.-weight)*transCol.GetAlpha();
343 return G4Colour(red,green,blue,alpha); 341 return G4Colour(red,green,blue,alpha);
344 } 342 }
345 343
346 G4Colour G4TheRayTracer::GetSurfaceColour(G4Ra 344 G4Colour G4TheRayTracer::GetSurfaceColour(G4RayTrajectoryPoint* point)
347 { 345 {
348 const G4VisAttributes* preAtt = point->GetPr 346 const G4VisAttributes* preAtt = point->GetPreStepAtt();
349 const G4VisAttributes* postAtt = point->GetP 347 const G4VisAttributes* postAtt = point->GetPostStepAtt();
350 348
351 G4bool preVis = ValidColour(preAtt); 349 G4bool preVis = ValidColour(preAtt);
352 G4bool postVis = ValidColour(postAtt); 350 G4bool postVis = ValidColour(postAtt);
353 351
354 G4Colour transparent(1.,1.,1.,0.); 352 G4Colour transparent(1.,1.,1.,0.);
355 353
356 if(!preVis&&!postVis) return transparent; 354 if(!preVis&&!postVis) return transparent;
357 355
358 G4ThreeVector normal = point->GetSurfaceNorm 356 G4ThreeVector normal = point->GetSurfaceNormal();
359 357
360 G4Colour preCol(1.,1.,1.); 358 G4Colour preCol(1.,1.,1.);
361 G4Colour postCol(1.,1.,1.); 359 G4Colour postCol(1.,1.,1.);
362 360
363 if(preVis) 361 if(preVis)
364 { 362 {
365 const G4Colour& preAttColour = preAtt->Get 363 const G4Colour& preAttColour = preAtt->GetColour();
366 G4double brill = (1.0-(-lightDirection).do 364 G4double brill = (1.0-(-lightDirection).dot(normal))/2.0;
367 G4double red = preAttColour.GetRed(); 365 G4double red = preAttColour.GetRed();
368 G4double green = preAttColour.GetGreen(); 366 G4double green = preAttColour.GetGreen();
369 G4double blue = preAttColour.GetBlue(); 367 G4double blue = preAttColour.GetBlue();
370 preCol = G4Colour 368 preCol = G4Colour
371 (red*brill,green*brill,blue*brill,preAtt 369 (red*brill,green*brill,blue*brill,preAttColour.GetAlpha());
372 } 370 }
373 else 371 else
374 { preCol = transparent; } 372 { preCol = transparent; }
375 373
376 if(postVis) 374 if(postVis)
377 { 375 {
378 const G4Colour& postAttColour = postAtt->G 376 const G4Colour& postAttColour = postAtt->GetColour();
379 G4double brill = (1.0-(-lightDirection).do 377 G4double brill = (1.0-(-lightDirection).dot(-normal))/2.0;
380 G4double red = postAttColour.GetRed(); 378 G4double red = postAttColour.GetRed();
381 G4double green = postAttColour.GetGreen(); 379 G4double green = postAttColour.GetGreen();
382 G4double blue = postAttColour.GetBlue(); 380 G4double blue = postAttColour.GetBlue();
383 postCol = G4Colour 381 postCol = G4Colour
384 (red*brill,green*brill,blue*brill,postAt 382 (red*brill,green*brill,blue*brill,postAttColour.GetAlpha());
385 } 383 }
386 else 384 else
387 { postCol = transparent; } 385 { postCol = transparent; }
388 386
389 if(!preVis) return postCol; 387 if(!preVis) return postCol;
390 if(!postVis) return preCol; 388 if(!postVis) return preCol;
391 389
392 G4double weight = 0.5; 390 G4double weight = 0.5;
393 return GetMixedColour(preCol,postCol,weight) 391 return GetMixedColour(preCol,postCol,weight);
394 } 392 }
395 393
396 G4Colour G4TheRayTracer::Attenuate 394 G4Colour G4TheRayTracer::Attenuate
397 (G4RayTrajectoryPoint* point,const G4Colour& s 395 (G4RayTrajectoryPoint* point,const G4Colour& sourceCol)
398 { 396 {
399 const G4VisAttributes* preAtt = point->GetPr 397 const G4VisAttributes* preAtt = point->GetPreStepAtt();
400 398
401 G4bool visible = ValidColour(preAtt); 399 G4bool visible = ValidColour(preAtt);
402 if(!visible) return sourceCol; 400 if(!visible) return sourceCol;
403 401
404 G4Colour objCol = preAtt->GetColour(); 402 G4Colour objCol = preAtt->GetColour();
405 G4double stepRed = objCol.GetRed(); 403 G4double stepRed = objCol.GetRed();
406 G4double stepGreen = objCol.GetGreen(); 404 G4double stepGreen = objCol.GetGreen();
407 G4double stepBlue = objCol.GetBlue(); 405 G4double stepBlue = objCol.GetBlue();
408 G4double stepAlpha = objCol.GetAlpha(); 406 G4double stepAlpha = objCol.GetAlpha();
409 G4double stepLength = point->GetStepLength() 407 G4double stepLength = point->GetStepLength();
410 408
411 G4double attenuationFuctor; 409 G4double attenuationFuctor;
412 if(stepAlpha > 0.9999999){ stepAlpha = 0.999 410 if(stepAlpha > 0.9999999){ stepAlpha = 0.9999999; } // patch to the next line
413 attenuationFuctor = -stepAlpha/(1.0-stepAl 411 attenuationFuctor = -stepAlpha/(1.0-stepAlpha)*stepLength/attenuationLength;
414 412
415 G4double KtRed = std::exp((1.0-stepRed)*atte 413 G4double KtRed = std::exp((1.0-stepRed)*attenuationFuctor);
416 G4double KtGreen = std::exp((1.0-stepGreen)* 414 G4double KtGreen = std::exp((1.0-stepGreen)*attenuationFuctor);
417 G4double KtBlue = std::exp((1.0-stepBlue)*at 415 G4double KtBlue = std::exp((1.0-stepBlue)*attenuationFuctor);
418 if(KtRed>1.0){KtRed=1.0;} 416 if(KtRed>1.0){KtRed=1.0;}
419 if(KtGreen>1.0){KtGreen=1.0;} 417 if(KtGreen>1.0){KtGreen=1.0;}
420 if(KtBlue>1.0){KtBlue=1.0;} 418 if(KtBlue>1.0){KtBlue=1.0;}
421 return G4Colour(sourceCol.GetRed()*KtRed, 419 return G4Colour(sourceCol.GetRed()*KtRed,
422 sourceCol.GetGreen()*KtGreen,sourceCol.Get 420 sourceCol.GetGreen()*KtGreen,sourceCol.GetBlue()*KtBlue);
423 } 421 }
424 422
425 G4bool G4TheRayTracer::ValidColour(const G4Vis 423 G4bool G4TheRayTracer::ValidColour(const G4VisAttributes* visAtt)
426 { 424 {
427 G4bool val = true; 425 G4bool val = true;
428 if(!visAtt) 426 if(!visAtt)
429 { val = false; } 427 { val = false; }
430 else if(!(visAtt->IsVisible())) 428 else if(!(visAtt->IsVisible()))
431 { val = false; } 429 { val = false; }
432 else if(visAtt->IsForceDrawingStyle() 430 else if(visAtt->IsForceDrawingStyle()
433 &&(visAtt->GetForcedDrawingStyle()==G4VisA 431 &&(visAtt->GetForcedDrawingStyle()==G4VisAttributes::wireframe))
434 { val = false; } 432 { val = false; }
435 return val; 433 return val;
436 } 434 }
437 435
438 436