Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4MaterialScanner.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 /run/src/G4MaterialScanner.cc (Version 11.3.0) and /run/src/G4MaterialScanner.cc (Version 11.2)


  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 // G4MaterialScanner implementation                26 // G4MaterialScanner implementation
 27 //                                                 27 //
 28 // Author: M.Asai, May 2006                        28 // Author: M.Asai, May 2006
 29 // -------------------------------------------     29 // --------------------------------------------------------------------
 30                                                    30 
 31 #include "G4MaterialScanner.hh"                    31 #include "G4MaterialScanner.hh"
 32                                                    32 
 33 #include "G4Event.hh"                              33 #include "G4Event.hh"
 34 #include "G4EventManager.hh"                       34 #include "G4EventManager.hh"
 35 #include "G4GeometryManager.hh"                    35 #include "G4GeometryManager.hh"
 36 #include "G4MSSteppingAction.hh"                   36 #include "G4MSSteppingAction.hh"
 37 #include "G4MatScanMessenger.hh"                   37 #include "G4MatScanMessenger.hh"
 38 #include "G4ProcessManager.hh"                     38 #include "G4ProcessManager.hh"
 39 #include "G4ProcessVector.hh"                      39 #include "G4ProcessVector.hh"
 40 #include "G4RayShooter.hh"                         40 #include "G4RayShooter.hh"
 41 #include "G4Region.hh"                             41 #include "G4Region.hh"
 42 #include "G4RegionStore.hh"                        42 #include "G4RegionStore.hh"
 43 #include "G4RunManagerKernel.hh"                   43 #include "G4RunManagerKernel.hh"
 44 #include "G4SDManager.hh"                          44 #include "G4SDManager.hh"
 45 #include "G4StateManager.hh"                       45 #include "G4StateManager.hh"
 46 #include "G4SystemOfUnits.hh"                      46 #include "G4SystemOfUnits.hh"
 47 #include "G4TransportationManager.hh"              47 #include "G4TransportationManager.hh"
 48                                                    48 
 49 // -------------------------------------------     49 // --------------------------------------------------------------------
 50 G4MaterialScanner::G4MaterialScanner()             50 G4MaterialScanner::G4MaterialScanner()
 51 {                                                  51 {
 52   theRayShooter = new G4RayShooter();              52   theRayShooter = new G4RayShooter();
 53   theMessenger = new G4MatScanMessenger(this);     53   theMessenger = new G4MatScanMessenger(this);
 54   theEventManager = G4EventManager::GetEventMa     54   theEventManager = G4EventManager::GetEventManager();
 55                                                    55 
 56   eyePosition = G4ThreeVector(0., 0., 0.);         56   eyePosition = G4ThreeVector(0., 0., 0.);
 57   thetaSpan = 90. * deg;                           57   thetaSpan = 90. * deg;
 58   phiSpan = 360. * deg;                            58   phiSpan = 360. * deg;
 59 }                                                  59 }
 60                                                    60 
 61 // -------------------------------------------     61 // --------------------------------------------------------------------
 62 G4MaterialScanner::~G4MaterialScanner()            62 G4MaterialScanner::~G4MaterialScanner()
 63 {                                                  63 {
 64   delete theRayShooter;                            64   delete theRayShooter;
 65   delete theMatScannerSteppingAction;              65   delete theMatScannerSteppingAction;
 66   delete theMessenger;                             66   delete theMessenger;
 67 }                                                  67 }
 68                                                    68 
 69 // -------------------------------------------     69 // --------------------------------------------------------------------
 70 void G4MaterialScanner::Scan()                     70 void G4MaterialScanner::Scan()
 71 {                                                  71 {
 72   G4StateManager* theStateMan = G4StateManager     72   G4StateManager* theStateMan = G4StateManager::GetStateManager();
 73   G4ApplicationState currentState = theStateMa     73   G4ApplicationState currentState = theStateMan->GetCurrentState();
 74   if (currentState != G4State_Idle) {              74   if (currentState != G4State_Idle) {
 75     G4cerr << "Illegal application state - Sca     75     G4cerr << "Illegal application state - Scan() ignored." << G4endl;
 76     return;                                        76     return;
 77   }                                                77   }
 78                                                    78 
 79   if (theMatScannerSteppingAction == nullptr)      79   if (theMatScannerSteppingAction == nullptr) {
 80     theMatScannerSteppingAction = new G4MSStep     80     theMatScannerSteppingAction = new G4MSSteppingAction();
 81   }                                                81   }
 82   StoreUserActions();                              82   StoreUserActions();
 83   DoScan();                                        83   DoScan();
 84   RestoreUserActions();                            84   RestoreUserActions();
 85 }                                                  85 }
 86                                                    86 
 87 // -------------------------------------------     87 // --------------------------------------------------------------------
 88 void G4MaterialScanner::StoreUserActions()         88 void G4MaterialScanner::StoreUserActions()
 89 {                                                  89 {
 90   theUserEventAction = theEventManager->GetUse     90   theUserEventAction = theEventManager->GetUserEventAction();
 91   theUserStackingAction = theEventManager->Get     91   theUserStackingAction = theEventManager->GetUserStackingAction();
 92   theUserTrackingAction = theEventManager->Get     92   theUserTrackingAction = theEventManager->GetUserTrackingAction();
 93   theUserSteppingAction = theEventManager->Get     93   theUserSteppingAction = theEventManager->GetUserSteppingAction();
 94                                                    94 
 95   theEventManager->SetUserAction(theMatScanner     95   theEventManager->SetUserAction(theMatScannerEventAction);
 96   theEventManager->SetUserAction(theMatScanner     96   theEventManager->SetUserAction(theMatScannerStackingAction);
 97   theEventManager->SetUserAction(theMatScanner     97   theEventManager->SetUserAction(theMatScannerTrackingAction);
 98   theEventManager->SetUserAction(theMatScanner     98   theEventManager->SetUserAction(theMatScannerSteppingAction);
 99                                                    99 
100   G4SDManager* theSDMan = G4SDManager::GetSDMp    100   G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
101   if (theSDMan != nullptr) {                      101   if (theSDMan != nullptr) {
102     theSDMan->Activate("/", false);               102     theSDMan->Activate("/", false);
103   }                                               103   }
104                                                   104 
105   G4GeometryManager* theGeomMan = G4GeometryMa    105   G4GeometryManager* theGeomMan = G4GeometryManager::GetInstance();
106   theGeomMan->OpenGeometry();                     106   theGeomMan->OpenGeometry();
107   theGeomMan->CloseGeometry(true);                107   theGeomMan->CloseGeometry(true);
108 }                                                 108 }
109                                                   109 
110 // -------------------------------------------    110 // --------------------------------------------------------------------
111 void G4MaterialScanner::RestoreUserActions()      111 void G4MaterialScanner::RestoreUserActions()
112 {                                                 112 {
113   theEventManager->SetUserAction(theUserEventA    113   theEventManager->SetUserAction(theUserEventAction);
114   theEventManager->SetUserAction(theUserStacki    114   theEventManager->SetUserAction(theUserStackingAction);
115   theEventManager->SetUserAction(theUserTracki    115   theEventManager->SetUserAction(theUserTrackingAction);
116   theEventManager->SetUserAction(theUserSteppi    116   theEventManager->SetUserAction(theUserSteppingAction);
117                                                   117 
118   G4SDManager* theSDMan = G4SDManager::GetSDMp    118   G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
119   if (theSDMan != nullptr) {                      119   if (theSDMan != nullptr) {
120     theSDMan->Activate("/", true);                120     theSDMan->Activate("/", true);
121   }                                               121   }
122 }                                                 122 }
123                                                   123 
124 // -------------------------------------------    124 // --------------------------------------------------------------------
125 void G4MaterialScanner::DoScan()                  125 void G4MaterialScanner::DoScan()
126 {                                                 126 {
127   // Confirm material table is updated            127   // Confirm material table is updated
128   G4RunManagerKernel::GetRunManagerKernel()->U    128   G4RunManagerKernel::GetRunManagerKernel()->UpdateRegion();
129                                                   129 
130   // Close geometry and set the application st    130   // Close geometry and set the application state
131   G4GeometryManager* geomManager = G4GeometryM    131   G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
132   geomManager->OpenGeometry();                    132   geomManager->OpenGeometry();
133   geomManager->CloseGeometry(true, false);        133   geomManager->CloseGeometry(true, false);
134                                                   134 
135   G4ThreeVector center(0, 0, 0);                  135   G4ThreeVector center(0, 0, 0);
136   G4Navigator* navigator =                        136   G4Navigator* navigator =
137     G4TransportationManager::GetTransportation    137     G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
138   navigator->LocateGlobalPointAndSetup(center,    138   navigator->LocateGlobalPointAndSetup(center, nullptr, false);
139                                                   139 
140   G4StateManager* theStateMan = G4StateManager    140   G4StateManager* theStateMan = G4StateManager::GetStateManager();
141   theStateMan->SetNewState(G4State_GeomClosed)    141   theStateMan->SetNewState(G4State_GeomClosed);
142                                                   142 
143   // Event loop                                   143   // Event loop
144   G4int iEvent = 0;                               144   G4int iEvent = 0;
145   for (G4int iTheta = 0; iTheta < nTheta; ++iT    145   for (G4int iTheta = 0; iTheta < nTheta; ++iTheta) {
146     G4double theta = thetaMin;                    146     G4double theta = thetaMin;
147     if (iTheta > 0) theta += G4double(iTheta)     147     if (iTheta > 0) theta += G4double(iTheta) * thetaSpan / G4double(nTheta - 1);
148     G4double aveLength = 0.;                      148     G4double aveLength = 0.;
149     G4double aveX0 = 0.;                          149     G4double aveX0 = 0.;
150     G4double aveLambda = 0.;                      150     G4double aveLambda = 0.;
151     G4cout << G4endl;                             151     G4cout << G4endl;
152     G4cout << "         Theta(deg)    Phi(deg)    152     G4cout << "         Theta(deg)    Phi(deg)  Length(mm)          x0     lambda0" << G4endl;
153     G4cout << G4endl;                             153     G4cout << G4endl;
154     for (G4int iPhi = 0; iPhi < nPhi; ++iPhi)     154     for (G4int iPhi = 0; iPhi < nPhi; ++iPhi) {
155       auto anEvent = new G4Event(iEvent++);       155       auto anEvent = new G4Event(iEvent++);
156       G4double phi = phiMin;                      156       G4double phi = phiMin;
157       if (iPhi > 0) phi += G4double(iPhi) * ph    157       if (iPhi > 0) phi += G4double(iPhi) * phiSpan / G4double(nPhi - 1);
158       eyeDirection = G4ThreeVector(std::cos(th    158       eyeDirection = G4ThreeVector(std::cos(theta) * std::cos(phi), std::cos(theta) * std::sin(phi),
159                                    std::sin(th    159                                    std::sin(theta));
160       theRayShooter->Shoot(anEvent, eyePositio    160       theRayShooter->Shoot(anEvent, eyePosition, eyeDirection);
161       theMatScannerSteppingAction->Initialize(    161       theMatScannerSteppingAction->Initialize(regionSensitive, theRegion);
162       theEventManager->ProcessOneEvent(anEvent    162       theEventManager->ProcessOneEvent(anEvent);
163       G4double length = theMatScannerSteppingA    163       G4double length = theMatScannerSteppingAction->GetTotalStepLength();
164       G4double x0 = theMatScannerSteppingActio    164       G4double x0 = theMatScannerSteppingAction->GetX0();
165       G4double lambda = theMatScannerSteppingA    165       G4double lambda = theMatScannerSteppingAction->GetLambda0();
166                                                   166 
167       G4cout << "        " << std::setw(11) <<    167       G4cout << "        " << std::setw(11) << theta / deg << " " << std::setw(11) << phi / deg
168              << " " << std::setw(11) << length    168              << " " << std::setw(11) << length / mm << " " << std::setw(11) << x0 << " "
169              << std::setw(11) << lambda;       << 169              << std::setw(11) << lambda << G4endl;
170       if(1 == verbosity)                       << 
171       {                                        << 
172         theMatScannerSteppingAction->PrintInte << 
173       }                                        << 
174       else if(2 == verbosity)                  << 
175       {                                        << 
176         theMatScannerSteppingAction->PrintEach << 
177       }                                        << 
178       G4cout << G4endl;                        << 
179       aveLength += length / mm;                   170       aveLength += length / mm;
180       aveX0 += x0;                                171       aveX0 += x0;
181       aveLambda += lambda;                        172       aveLambda += lambda;
182     }                                             173     }
183     if (nPhi > 1) {                               174     if (nPhi > 1) {
184       G4cout << G4endl;                           175       G4cout << G4endl;
185       G4cout << " ave. for theta = " << std::s    176       G4cout << " ave. for theta = " << std::setw(11) << theta / deg << " : " << std::setw(11)
186              << aveLength / nPhi << " " << std    177              << aveLength / nPhi << " " << std::setw(11) << aveX0 / nPhi << " " << std::setw(11)
187              << aveLambda / nPhi << G4endl;       178              << aveLambda / nPhi << G4endl;
188     }                                             179     }
189   }                                               180   }
190                                                   181 
191   theStateMan->SetNewState(G4State_Idle);         182   theStateMan->SetNewState(G4State_Idle);
192   return;                                         183   return;
193 }                                                 184 }
194                                                   185 
195 // -------------------------------------------    186 // --------------------------------------------------------------------
196 G4bool G4MaterialScanner::SetRegionName(const     187 G4bool G4MaterialScanner::SetRegionName(const G4String& val)
197 {                                                 188 {
198   G4Region* aRegion = G4RegionStore::GetInstan    189   G4Region* aRegion = G4RegionStore::GetInstance()->GetRegion(val);
199   if (aRegion != nullptr) {                       190   if (aRegion != nullptr) {
200     theRegion = aRegion;                          191     theRegion = aRegion;
201     regionName = val;                             192     regionName = val;
202     return true;                                  193     return true;
203   }                                               194   }
204                                                   195 
205   G4cerr << "Region <" << val << "> not found.    196   G4cerr << "Region <" << val << "> not found. Command ignored." << G4endl;
206   G4cerr << "Defined regions are : " << G4endl    197   G4cerr << "Defined regions are : " << G4endl;
207   for (const auto& i : *G4RegionStore::GetInst    198   for (const auto& i : *G4RegionStore::GetInstance()) {
208     G4cerr << " " << i->GetName();                199     G4cerr << " " << i->GetName();
209   }                                               200   }
210   G4cerr << G4endl;                               201   G4cerr << G4endl;
211   return false;                                   202   return false;
212 }                                                 203 }
213                                                   204