Geant4  10.02
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 86973 2014-11-21 11:57:27Z 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;
74  colorR = 0;
75  colorG = 0;
76  colorB = 0;
77 
80 
81  nColumn = 640;
82  nRow = 640;
83 
84  eyePosition = G4ThreeVector(1.*m,1.*m,1.*m);
85  targetPosition = G4ThreeVector(0.,0.,0.);
86  lightDirection = G4ThreeVector(-0.1,-0.2,-0.3).unit();
87  up = G4ThreeVector(0,1,0);
88  viewSpan = 5.0*deg;
89  headAngle = 0.;
90  attenuationLength = 1.0*m;
91 
92  distortionOn = false;
93  antialiasingOn = false;
94 
95  backgroundColour = G4Colour(1.,1.,1.);
96 }
97 
99 {
100  delete theRayShooter;
103  delete theMessenger;
104  delete theScanner;
105  delete theFigMaker;
106 }
107 
108 void G4TheRayTracer::Trace(const G4String& fileName)
109 {
111  G4ApplicationState currentState = theStateMan->GetCurrentState();
112  if(currentState!=G4State_Idle)
113  {
114  G4cerr << "Illegal application state - Trace() ignored." << G4endl;
115  return;
116  }
117 
118  if(!theFigMaker)
119  {
120  G4cerr << "Figure file maker class is not specified - Trace() ignored." << G4endl;
121  return;
122  }
123 
125  G4int storeTrajectory = UI->GetCurrentIntValue("/tracking/storeTrajectory");
126  if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 1");
127 
128 
130  eyeDirection = tmpVec.unit();
131  colorR = new unsigned char[nColumn*nRow];
132  colorG = new unsigned char[nColumn*nRow];
133  colorB = new unsigned char[nColumn*nRow];
134 
136  G4bool succeeded = CreateBitMap();
137  if(succeeded)
138  { CreateFigureFile(fileName); }
139  else
140  { G4cerr << "Could not create figure file" << G4endl;
141  G4cerr << "You might set the eye position outside of the world volume" << G4endl; }
143 
144  if(storeTrajectory==0) UI->ApplyCommand("/tracking/storeTrajectory 0");
145 
146  delete [] colorR;
147  delete [] colorG;
148  delete [] colorB;
149 }
150 
152 {
157 
160 
165 
167  if(theSDMan)
168  { theSDMan->Activate("/",false); }
169 
171  theGeomMan->OpenGeometry();
172  theGeomMan->CloseGeometry(true);
173 }
174 
176 {
181 
183  if(theSDMan)
184  { theSDMan->Activate("/",true); }
185 }
186 
187 #include "G4ProcessManager.hh"
188 #include "G4ProcessVector.hh"
189 #include "G4Geantino.hh"
190 
192 {
193  G4int iEvent = 0;
194  G4double stepAngle = viewSpan/100.;
195  G4double viewSpanX = stepAngle*nColumn;
196  G4double viewSpanY = stepAngle*nRow;
197  G4bool succeeded;
198 
200  visMan->IgnoreStateChanges(true);
201 
202 // Confirm process(es) of Geantino is initialized
203  G4VPhysicalVolume* pWorld =
205  GetNavigatorForTracking()->GetWorldVolume();
208  G4ProcessVector* pVector
210  for (G4int j=0; j < pVector->size(); ++j) {
211  (*pVector)[j]->BuildPhysicsTable(*(G4Geantino::GeantinoDefinition()));
212  }
213 
214 // Close geometry and set the application state
216  geomManager->OpenGeometry();
217  geomManager->CloseGeometry(1,0);
218 
219  G4ThreeVector center(0,0,0);
220  G4Navigator* navigator =
222  navigator->LocateGlobalPointAndSetup(center,0,false);
223 
225  theStateMan->SetNewState(G4State_GeomClosed);
226 
227 // Event loop
228  theScanner->Initialize(nRow,nColumn);
229  G4int iRow, iColumn;
230  while (theScanner->Coords(iRow,iColumn)) {
231  G4int iCoord = iRow * nColumn + iColumn;
232  G4double dRow = 0, dColumn = 0; // Antialiasing increments.
233  G4Event* anEvent = new G4Event(iEvent++);
234  G4double angleX = -(viewSpanX/2. - (iColumn+dColumn)*stepAngle);
235  G4double angleY = viewSpanY/2. - (iRow+dRow)*stepAngle;
236  G4ThreeVector rayDirection;
237  if(distortionOn)
238  {
239  rayDirection = G4ThreeVector(-std::tan(angleX)/std::cos(angleY),std::tan(angleY)/std::cos(angleX),1.0);
240  }
241  else
242  {
243  rayDirection = G4ThreeVector(-std::tan(angleX),std::tan(angleY),1.0);
244  }
245  G4double cp = std::cos(eyeDirection.phi());
246  G4double sp = std::sqrt(1.-cp*cp);
247  G4double ct = std::cos(eyeDirection.theta());
248  G4double st = std::sqrt(1.-ct*ct);
249  G4double gamma = std::atan2(ct*cp*up.x()+ct*sp*up.y()-st*up.z(), -sp*up.x()+cp*up.y());
250  rayDirection.rotateZ(-gamma);
251  rayDirection.rotateZ(headAngle);
252  rayDirection.rotateUz(eyeDirection);
253  G4ThreeVector rayPosition(eyePosition);
254  G4bool interceptable = true;
255  // Check if rayPosition is in the world.
256  EInside whereisit =
257  pWorld->GetLogicalVolume()->GetSolid()->Inside(rayPosition);
258  if (whereisit != kInside) {
259  // It's outside the world, so move it inside.
260  G4double outsideDistance =
261  pWorld->GetLogicalVolume()->GetSolid()->
262  DistanceToIn(rayPosition,rayDirection);
263  if (outsideDistance != kInfinity) {
264  // Borrowing from geometry, where 1e-8 < epsilon < 1e-3, in
265  // absolute/internal length units, is used for ensuring good
266  // behaviour, choose to add 0.001 to ensure rayPosition is
267  // definitely inside the world volume (JA 16/9/2005)...
268  rayPosition = rayPosition+(outsideDistance+0.001)*rayDirection;
269  }
270  else {
271  interceptable = false;
272  }
273  }
274  if (interceptable) {
275  theRayShooter->Shoot(anEvent,rayPosition,rayDirection.unit());
277  succeeded = GenerateColour(anEvent);
278  colorR[iCoord] = (unsigned char)(int(255*rayColour.GetRed()));
279  colorG[iCoord] = (unsigned char)(int(255*rayColour.GetGreen()));
280  colorB[iCoord] = (unsigned char)(int(255*rayColour.GetBlue()));
281  } else { // Ray does not intercept world at all.
282  // Store background colour...
283  colorR[iCoord] = (unsigned char)(int(255*backgroundColour.GetRed()));
284  colorG[iCoord] = (unsigned char)(int(255*backgroundColour.GetGreen()));
285  colorB[iCoord] = (unsigned char)(int(255*backgroundColour.GetBlue()));
286  succeeded = true;
287  }
288 
289  theScanner->Draw(colorR[iCoord],colorG[iCoord],colorB[iCoord]);
290 
291  delete anEvent;
292  if(!succeeded) return false;
293  }
294 
295  theStateMan->SetNewState(G4State_Idle);
296  visMan->IgnoreStateChanges(false);
297  return true;
298 }
299 
301 {
302  //G4cout << nColumn << " " << nRow << G4endl;
304 }
305 
307 {
308  G4TrajectoryContainer * trajectoryContainer = anEvent->GetTrajectoryContainer();
309 
310  G4RayTrajectory* trajectory = (G4RayTrajectory*)( (*trajectoryContainer)[0] );
311  if(!trajectory) return false;
312 
313  G4int nPoint = trajectory->GetPointEntries();
314  if(nPoint==0) return false;
315 
316  G4Colour initialColour(backgroundColour);
317  if( trajectory->GetPointC(nPoint-1)->GetPostStepAtt() )
318  { initialColour = GetSurfaceColour(trajectory->GetPointC(nPoint-1)); }
319  rayColour = Attenuate(trajectory->GetPointC(nPoint-1),initialColour);
320 
321  for(int i=nPoint-2;i>=0;i--)
322  {
323  G4Colour surfaceColour = GetSurfaceColour(trajectory->GetPointC(i));
324  G4double weight = 1.0 - surfaceColour.GetAlpha();
325  G4Colour mixedColour = GetMixedColour(rayColour,surfaceColour,weight);
326  rayColour = Attenuate(trajectory->GetPointC(i),mixedColour);
327  }
328 
329  return true;
330 }
331 
333 (const G4Colour& surfCol,const G4Colour& transCol,G4double weight)
334 {
335  G4double red = weight*surfCol.GetRed() + (1.-weight)*transCol.GetRed();
336  G4double green = weight*surfCol.GetGreen() + (1.-weight)*transCol.GetGreen();
337  G4double blue = weight*surfCol.GetBlue() + (1.-weight)*transCol.GetBlue();
338  G4double alpha = weight*surfCol.GetAlpha() + (1.-weight)*transCol.GetAlpha();
339  return G4Colour(red,green,blue,alpha);
340 }
341 
343 {
344  const G4VisAttributes* preAtt = point->GetPreStepAtt();
345  const G4VisAttributes* postAtt = point->GetPostStepAtt();
346 
347  G4bool preVis = ValidColour(preAtt);
348  G4bool postVis = ValidColour(postAtt);
349 
350  G4Colour transparent(1.,1.,1.,0.);
351 
352  if(!preVis&&!postVis) return transparent;
353 
355 
356  G4Colour preCol(1.,1.,1.);
357  G4Colour postCol(1.,1.,1.);
358 
359  if(preVis)
360  {
361  const G4Colour& preAttColour = preAtt->GetColour();
362  G4double brill = (1.0-(-lightDirection).dot(normal))/2.0;
363  G4double red = preAttColour.GetRed();
364  G4double green = preAttColour.GetGreen();
365  G4double blue = preAttColour.GetBlue();
366  preCol = G4Colour
367  (red*brill,green*brill,blue*brill,preAttColour.GetAlpha());
368  }
369  else
370  { preCol = transparent; }
371 
372  if(postVis)
373  {
374  const G4Colour& postAttColour = postAtt->GetColour();
375  G4double brill = (1.0-(-lightDirection).dot(-normal))/2.0;
376  G4double red = postAttColour.GetRed();
377  G4double green = postAttColour.GetGreen();
378  G4double blue = postAttColour.GetBlue();
379  postCol = G4Colour
380  (red*brill,green*brill,blue*brill,postAttColour.GetAlpha());
381  }
382  else
383  { postCol = transparent; }
384 
385  if(!preVis) return postCol;
386  if(!postVis) return preCol;
387 
388  G4double weight = 0.5;
389  return GetMixedColour(preCol,postCol,weight);
390 }
391 
393 (G4RayTrajectoryPoint* point,const G4Colour& sourceCol)
394 {
395  const G4VisAttributes* preAtt = point->GetPreStepAtt();
396 
397  G4bool visible = ValidColour(preAtt);
398  if(!visible) return sourceCol;
399 
400  G4Colour objCol = preAtt->GetColour();
401  G4double stepRed = objCol.GetRed();
402  G4double stepGreen = objCol.GetGreen();
403  G4double stepBlue = objCol.GetBlue();
404  G4double stepAlpha = objCol.GetAlpha();
405  G4double stepLength = point->GetStepLength();
406 
407  G4double attenuationFuctor;
408  if(stepAlpha > 0.9999999){ stepAlpha = 0.9999999; } // patch to the next line
409  attenuationFuctor = -stepAlpha/(1.0-stepAlpha)*stepLength/attenuationLength;
410 
411  G4double KtRed = std::exp((1.0-stepRed)*attenuationFuctor);
412  G4double KtGreen = std::exp((1.0-stepGreen)*attenuationFuctor);
413  G4double KtBlue = std::exp((1.0-stepBlue)*attenuationFuctor);
414  if(KtRed>1.0){KtRed=1.0;}
415  if(KtGreen>1.0){KtGreen=1.0;}
416  if(KtBlue>1.0){KtBlue=1.0;}
417  return G4Colour(sourceCol.GetRed()*KtRed,
418  sourceCol.GetGreen()*KtGreen,sourceCol.GetBlue()*KtBlue);
419 }
420 
422 {
423  G4bool val = true;
424  if(!visAtt)
425  { val = false; }
426  else if(!(visAtt->IsVisible()))
427  { val = false; }
428  else if(visAtt->IsForceDrawingStyle()
430  { val = false; }
431  return val;
432 }
433 
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:189
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:151
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:232
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:122
#define G4endl
Definition: G4ios.hh:61
static const double m
Definition: G4SIunits.hh:128
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:446
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