Geant4  10.00.p02
G4TheRayTracer.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4TheRayTracer.cc 77479 2013-11-25 10:01:22Z gcosmo $
28 //
29 //
30 //
31 
32 
33 #include "G4TheRayTracer.hh"
34 #include "G4SystemOfUnits.hh"
35 #include "G4EventManager.hh"
36 #include "G4RTMessenger.hh"
37 #include "G4RayShooter.hh"
38 #include "G4VFigureFileMaker.hh"
39 #include "G4RTTrackingAction.hh"
40 #include "G4RTSteppingAction.hh"
41 #include "G4RayTrajectory.hh"
42 #include "G4RayTrajectoryPoint.hh"
43 #include "G4RTJpegMaker.hh"
44 #include "G4RTSimpleScanner.hh"
45 #include "G4GeometryManager.hh"
46 #include "G4SDManager.hh"
47 #include "G4StateManager.hh"
48 #include "G4Event.hh"
49 #include "G4TrajectoryContainer.hh"
50 #include "G4Colour.hh"
51 #include "G4VisAttributes.hh"
52 #include "G4UImanager.hh"
54 #include "G4RegionStore.hh"
55 #include "G4ProductionCutsTable.hh"
56 #include "G4VVisManager.hh"
57 
59  G4VRTScanner* scanner)
60 {
61  theFigMaker = figMaker;
63  theScanner = scanner;
72 
73  nColumn = 640;
74  nRow = 640;
75 
76  eyePosition = G4ThreeVector(1.*m,1.*m,1.*m);
77  targetPosition = G4ThreeVector(0.,0.,0.);
78  lightDirection = G4ThreeVector(-0.1,-0.2,-0.3).unit();
79  up = G4ThreeVector(0,1,0);
80  viewSpan = 5.0*deg;
81  headAngle = 0.;
82  attenuationLength = 1.0*m;
83 
84  distortionOn = false;
85  antialiasingOn = false;
86 
87  backgroundColour = G4Colour(1.,1.,1.);
88 }
89 
91 {
92  delete theRayShooter;
95  delete theMessenger;
96  delete theScanner;
97  delete theFigMaker;
98 }
99 
100 void G4TheRayTracer::Trace(const G4String& fileName)
101 {
103  G4ApplicationState currentState = theStateMan->GetCurrentState();
104  if(currentState!=G4State_Idle)
105  {
106  G4cerr << "Illegal application state - Trace() ignored." << G4endl;
107  return;
108  }
109 
110  if(!theFigMaker)
111  {
112  G4cerr << "Figure file maker class is not specified - Trace() ignored." << G4endl;
113  return;
114  }
115 
117  G4int storeTrajectory = UI->GetCurrentIntValue("/tracking/storeTrajectory");
118  if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 1");
119 
120 
122  eyeDirection = tmpVec.unit();
123  colorR = new unsigned char[nColumn*nRow];
124  colorG = new unsigned char[nColumn*nRow];
125  colorB = new unsigned char[nColumn*nRow];
126 
128  G4bool succeeded = CreateBitMap();
129  if(succeeded)
130  { CreateFigureFile(fileName); }
131  else
132  { G4cerr << "Could not create figure file" << G4endl;
133  G4cerr << "You might set the eye position outside of the world volume" << G4endl; }
135 
136  if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 0");
137 
138  delete [] colorR;
139  delete [] colorG;
140  delete [] colorB;
141 }
142 
144 {
149 
152 
157 
159  if(theSDMan)
160  { theSDMan->Activate("/",false); }
161 
163  theGeomMan->OpenGeometry();
164  theGeomMan->CloseGeometry(true);
165 }
166 
168 {
173 
175  if(theSDMan)
176  { theSDMan->Activate("/",true); }
177 }
178 
179 #include "G4ProcessManager.hh"
180 #include "G4ProcessVector.hh"
181 #include "G4Geantino.hh"
182 
184 {
185  G4int iEvent = 0;
186  G4double stepAngle = viewSpan/100.;
187  G4double viewSpanX = stepAngle*nColumn;
188  G4double viewSpanY = stepAngle*nRow;
189  G4bool succeeded;
190 
192  visMan->IgnoreStateChanges(true);
193 
194 // Confirm process(es) of Geantino is initialized
195  G4VPhysicalVolume* pWorld =
197  GetNavigatorForTracking()->GetWorldVolume();
200  G4ProcessVector* pVector
202  for (G4int j=0; j < pVector->size(); ++j) {
203  (*pVector)[j]->BuildPhysicsTable(*(G4Geantino::GeantinoDefinition()));
204  }
205 
206 // Close geometry and set the application state
208  geomManager->OpenGeometry();
209  geomManager->CloseGeometry(1,0);
210 
211  G4ThreeVector center(0,0,0);
212  G4Navigator* navigator =
214  navigator->LocateGlobalPointAndSetup(center,0,false);
215 
217  theStateMan->SetNewState(G4State_GeomClosed);
218 
219 // Event loop
220  theScanner->Initialize(nRow,nColumn);
221  G4int iRow, iColumn;
222  while (theScanner->Coords(iRow,iColumn)) {
223  G4int iCoord = iRow * nColumn + iColumn;
224  G4double dRow = 0, dColumn = 0; // Antialiasing increments.
225  G4Event* anEvent = new G4Event(iEvent++);
226  G4double angleX = -(viewSpanX/2. - (iColumn+dColumn)*stepAngle);
227  G4double angleY = viewSpanY/2. - (iRow+dRow)*stepAngle;
228  G4ThreeVector rayDirection;
229  if(distortionOn)
230  {
231  rayDirection = G4ThreeVector(-std::tan(angleX)/std::cos(angleY),std::tan(angleY)/std::cos(angleX),1.0);
232  }
233  else
234  {
235  rayDirection = G4ThreeVector(-std::tan(angleX),std::tan(angleY),1.0);
236  }
237  G4double cp = std::cos(eyeDirection.phi());
238  G4double sp = std::sqrt(1.-cp*cp);
239  G4double ct = std::cos(eyeDirection.theta());
240  G4double st = std::sqrt(1.-ct*ct);
241  G4double gamma = std::atan2(ct*cp*up.x()+ct*sp*up.y()-st*up.z(), -sp*up.x()+cp*up.y());
242  rayDirection.rotateZ(-gamma);
243  rayDirection.rotateZ(headAngle);
244  rayDirection.rotateUz(eyeDirection);
245  G4ThreeVector rayPosition(eyePosition);
246  G4bool interceptable = true;
247  // Check if rayPosition is in the world.
248  EInside whereisit =
249  pWorld->GetLogicalVolume()->GetSolid()->Inside(rayPosition);
250  if (whereisit != kInside) {
251  // It's outside the world, so move it inside.
252  G4double outsideDistance =
253  pWorld->GetLogicalVolume()->GetSolid()->
254  DistanceToIn(rayPosition,rayDirection);
255  if (outsideDistance != kInfinity) {
256  // Borrowing from geometry, where 1e-8 < epsilon < 1e-3, in
257  // absolute/internal length units, is used for ensuring good
258  // behaviour, choose to add 0.001 to ensure rayPosition is
259  // definitely inside the world volume (JA 16/9/2005)...
260  rayPosition = rayPosition+(outsideDistance+0.001)*rayDirection;
261  }
262  else {
263  interceptable = false;
264  }
265  }
266  if (interceptable) {
267  theRayShooter->Shoot(anEvent,rayPosition,rayDirection.unit());
269  succeeded = GenerateColour(anEvent);
270  colorR[iCoord] = (unsigned char)(int(255*rayColour.GetRed()));
271  colorG[iCoord] = (unsigned char)(int(255*rayColour.GetGreen()));
272  colorB[iCoord] = (unsigned char)(int(255*rayColour.GetBlue()));
273  } else { // Ray does not intercept world at all.
274  // Store background colour...
275  colorR[iCoord] = (unsigned char)(int(255*backgroundColour.GetRed()));
276  colorG[iCoord] = (unsigned char)(int(255*backgroundColour.GetGreen()));
277  colorB[iCoord] = (unsigned char)(int(255*backgroundColour.GetBlue()));
278  succeeded = true;
279  }
280 
281  theScanner->Draw(colorR[iCoord],colorG[iCoord],colorB[iCoord]);
282 
283  delete anEvent;
284  if(!succeeded) return false;
285  }
286 
287  theStateMan->SetNewState(G4State_Idle);
288  visMan->IgnoreStateChanges(false);
289  return true;
290 }
291 
293 {
294  //G4cout << nColumn << " " << nRow << G4endl;
296 }
297 
299 {
300  G4TrajectoryContainer * trajectoryContainer = anEvent->GetTrajectoryContainer();
301 
302  G4RayTrajectory* trajectory = (G4RayTrajectory*)( (*trajectoryContainer)[0] );
303  if(!trajectory) return false;
304 
305  G4int nPoint = trajectory->GetPointEntries();
306  if(nPoint==0) return false;
307 
308  G4Colour initialColour(backgroundColour);
309  if( trajectory->GetPointC(nPoint-1)->GetPostStepAtt() )
310  { initialColour = GetSurfaceColour(trajectory->GetPointC(nPoint-1)); }
311  rayColour = Attenuate(trajectory->GetPointC(nPoint-1),initialColour);
312 
313  for(int i=nPoint-2;i>=0;i--)
314  {
315  G4Colour surfaceColour = GetSurfaceColour(trajectory->GetPointC(i));
316  G4double weight = 1.0 - surfaceColour.GetAlpha();
317  G4Colour mixedColour = GetMixedColour(rayColour,surfaceColour,weight);
318  rayColour = Attenuate(trajectory->GetPointC(i),mixedColour);
319  }
320 
321  return true;
322 }
323 
325 (const G4Colour& surfCol,const G4Colour& transCol,G4double weight)
326 {
327  G4double red = weight*surfCol.GetRed() + (1.-weight)*transCol.GetRed();
328  G4double green = weight*surfCol.GetGreen() + (1.-weight)*transCol.GetGreen();
329  G4double blue = weight*surfCol.GetBlue() + (1.-weight)*transCol.GetBlue();
330  G4double alpha = weight*surfCol.GetAlpha() + (1.-weight)*transCol.GetAlpha();
331  return G4Colour(red,green,blue,alpha);
332 }
333 
335 {
336  const G4VisAttributes* preAtt = point->GetPreStepAtt();
337  const G4VisAttributes* postAtt = point->GetPostStepAtt();
338 
339  G4bool preVis = ValidColour(preAtt);
340  G4bool postVis = ValidColour(postAtt);
341 
342  G4Colour transparent(1.,1.,1.,0.);
343 
344  if(!preVis&&!postVis) return transparent;
345 
347 
348  G4Colour preCol(1.,1.,1.);
349  G4Colour postCol(1.,1.,1.);
350 
351  if(preVis)
352  {
353  const G4Colour& preAttColour = preAtt->GetColour();
354  G4double brill = (1.0-(-lightDirection).dot(normal))/2.0;
355  G4double red = preAttColour.GetRed();
356  G4double green = preAttColour.GetGreen();
357  G4double blue = preAttColour.GetBlue();
358  preCol = G4Colour
359  (red*brill,green*brill,blue*brill,preAttColour.GetAlpha());
360  }
361  else
362  { preCol = transparent; }
363 
364  if(postVis)
365  {
366  const G4Colour& postAttColour = postAtt->GetColour();
367  G4double brill = (1.0-(-lightDirection).dot(-normal))/2.0;
368  G4double red = postAttColour.GetRed();
369  G4double green = postAttColour.GetGreen();
370  G4double blue = postAttColour.GetBlue();
371  postCol = G4Colour
372  (red*brill,green*brill,blue*brill,postAttColour.GetAlpha());
373  }
374  else
375  { postCol = transparent; }
376 
377  if(!preVis) return postCol;
378  if(!postVis) return preCol;
379 
380  G4double weight = 0.5;
381  return GetMixedColour(preCol,postCol,weight);
382 }
383 
385 (G4RayTrajectoryPoint* point,const G4Colour& sourceCol)
386 {
387  const G4VisAttributes* preAtt = point->GetPreStepAtt();
388 
389  G4bool visible = ValidColour(preAtt);
390  if(!visible) return sourceCol;
391 
392  G4Colour objCol = preAtt->GetColour();
393  G4double stepRed = objCol.GetRed();
394  G4double stepGreen = objCol.GetGreen();
395  G4double stepBlue = objCol.GetBlue();
396  G4double stepAlpha = objCol.GetAlpha();
397  G4double stepLength = point->GetStepLength();
398 
399  G4double attenuationFuctor;
400  if(stepAlpha > 0.9999999){ stepAlpha = 0.9999999; } // patch to the next line
401  attenuationFuctor = -stepAlpha/(1.0-stepAlpha)*stepLength/attenuationLength;
402 
403  G4double KtRed = std::exp((1.0-stepRed)*attenuationFuctor);
404  G4double KtGreen = std::exp((1.0-stepGreen)*attenuationFuctor);
405  G4double KtBlue = std::exp((1.0-stepBlue)*attenuationFuctor);
406  if(KtRed>1.0){KtRed=1.0;}
407  if(KtGreen>1.0){KtGreen=1.0;}
408  if(KtBlue>1.0){KtBlue=1.0;}
409  return G4Colour(sourceCol.GetRed()*KtRed,
410  sourceCol.GetGreen()*KtGreen,sourceCol.GetBlue()*KtBlue);
411 }
412 
414 {
415  G4bool val = true;
416  if(!visAtt)
417  { val = false; }
418  else if(!(visAtt->IsVisible()))
419  { val = false; }
420  else if(visAtt->IsForceDrawingStyle()
422  { val = false; }
423  return val;
424 }
425 
virtual void StoreUserActions()
static G4Geantino * GeantinoDefinition()
Definition: G4Geantino.cc:82
G4double GetAlpha() const
Definition: G4Colour.hh:142
void UpdateMaterialList(G4VPhysicalVolume *currentWorld=0)
Definition: test07.cc:36
static const G4double kInfinity
Definition: geomdefs.hh:42
G4Colour GetSurfaceColour(G4RayTrajectoryPoint *point)
CLHEP::Hep3Vector G4ThreeVector
G4ThreeVector targetPosition
static G4VVisManager * GetConcreteInstance()
G4Colour Attenuate(G4RayTrajectoryPoint *point, const G4Colour &sourceCol)
G4UserStackingAction * theRayTracerStackingAction
G4UserStackingAction * theUserStackingAction
G4RTSteppingAction * theRayTracerSteppingAction
G4UserTrackingAction * theUserTrackingAction
G4RayShooter * theRayShooter
G4UserSteppingAction * theUserSteppingAction
virtual void RestoreUserActions()
const G4VisAttributes * GetPreStepAtt() const
G4Navigator * GetNavigatorForTracking() const
G4bool IsVisible() const
const G4Colour & GetColour() const
static G4RTMessenger * GetInstance(G4TheRayTracer *p1)
virtual G4bool Coords(G4int &iRow, G4int &iColumn)=0
void CreateFigureFile(const G4String &fileName)
G4double GetBlue() const
Definition: G4Colour.hh:141
G4VRTScanner * theScanner
G4ThreeVector eyeDirection
Definition: test07.cc:36
G4ProcessManager * GetProcessManager() const
int G4int
Definition: G4Types.hh:78
G4TrajectoryContainer * GetTrajectoryContainer() const
Definition: G4Event.hh:178
G4UserEventAction * GetUserEventAction()
virtual int GetPointEntries() const
G4UserEventAction * theUserEventAction
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
static double normal(HepRandomEngine *eptr)
Definition: RandPoisson.cc:77
static G4RegionStore * GetInstance()
unsigned char * colorR
G4ThreeVector lightDirection
static G4StateManager * GetStateManager()
virtual void Draw(unsigned char red, unsigned char green, unsigned char blue)
Definition: G4VRTScanner.hh:71
virtual void Trace(const G4String &fileName)
G4bool SetNewState(G4ApplicationState requestedState)
G4double GetRed() const
Definition: G4Colour.hh:139
virtual void IgnoreStateChanges(G4bool)
virtual void Initialize(G4int nRow, G4int nColumn)=0
virtual EInside Inside(const G4ThreeVector &p) const =0
static const double deg
Definition: G4SIunits.hh:133
void Activate(G4String dName, G4bool activeFlag)
Definition: G4SDManager.cc:117
bool G4bool
Definition: G4Types.hh:79
G4UserSteppingAction * GetUserSteppingAction()
G4double GetGreen() const
Definition: G4Colour.hh:140
G4ThreeVector up
G4Colour GetMixedColour(const G4Colour &surfCol, const G4Colour &transCol, G4double weight=0.5)
virtual G4bool CreateBitMap()
G4ThreeVector GetSurfaceNormal() const
G4ApplicationState GetCurrentState() const
static G4GeometryManager * GetInstance()
G4int GetCurrentIntValue(const char *aCommand, G4int parameterNumber=1, G4bool reGet=true)
Definition: G4UImanager.cc:218
virtual void CreateFigureFile(const G4String &fileName, int nColumn, int nRow, unsigned char *colorR, unsigned char *colorG, unsigned char *colorB)=0
static G4TransportationManager * GetTransportationManager()
const G4VisAttributes * GetPostStepAtt() const
G4EventManager * theEventManager
G4bool ValidColour(const G4VisAttributes *visAtt)
G4int size() const
static G4ProductionCutsTable * GetProductionCutsTable()
G4RTTrackingAction * theRayTracerTrackingAction
G4LogicalVolume * GetLogicalVolume() const
G4VFigureFileMaker * theFigMaker
void Shoot(G4Event *evt, G4ThreeVector vtx, G4ThreeVector direc)
Definition: G4RayShooter.cc:59
void SetUserAction(G4UserEventAction *userAction)
EInside
Definition: geomdefs.hh:58
G4RayTrajectoryPoint * GetPointC(G4int i) const
unsigned char * colorB
G4UserTrackingAction * GetUserTrackingAction()
G4bool IsForceDrawingStyle() const
G4UserEventAction * theRayTracerEventAction
static G4EventManager * GetEventManager()
virtual G4VPhysicalVolume * LocateGlobalPointAndSetup(const G4ThreeVector &point, const G4ThreeVector *direction=0, const G4bool pRelativeSearch=true, const G4bool ignoreDirection=true)
Definition: G4Navigator.cc:118
#define G4endl
Definition: G4ios.hh:61
static const double m
Definition: G4SIunits.hh:110
void OpenGeometry(G4VPhysicalVolume *vol=0)
void ProcessOneEvent(G4Event *anEvent)
void UpdateCoupleTable(G4VPhysicalVolume *currentWorld)
G4Colour backgroundColour
double G4double
Definition: G4Types.hh:76
G4double GetStepLength() const
G4ThreeVector eyePosition
G4TheRayTracer(G4VFigureFileMaker *figMaker=0, G4VRTScanner *scanner=0)
static const G4double alpha
G4double attenuationLength
G4RTMessenger * theMessenger
ForcedDrawingStyle GetForcedDrawingStyle() const
G4bool CloseGeometry(G4bool pOptimise=true, G4bool verbose=false, G4VPhysicalVolume *vol=0)
G4bool GenerateColour(G4Event *anEvent)
G4ApplicationState
G4UserStackingAction * GetUserStackingAction()
virtual ~G4TheRayTracer()
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:432
static const G4double cp
G4ProcessVector * GetProcessList() const
G4VSolid * GetSolid() const
G4GLOB_DLL std::ostream G4cerr
static G4SDManager * GetSDMpointerIfExist()
Definition: G4SDManager.cc:49
unsigned char * colorG