Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/RayTracer/src/G4TheRayTracer.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/RayTracer/src/G4TheRayTracer.cc (Version 11.3.0) and /visualization/RayTracer/src/G4TheRayTracer.cc (Version 9.0)


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