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.0.p4)


  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   {
 75     G4cerr << "Illegal application state - Sca     76     G4cerr << "Illegal application state - Scan() ignored." << G4endl;
 76     return;                                        77     return;
 77   }                                                78   }
 78                                                    79 
 79   if (theMatScannerSteppingAction == nullptr)  <<  80   if(theMatScannerSteppingAction == nullptr)
                                                   >>  81   {
 80     theMatScannerSteppingAction = new G4MSStep     82     theMatScannerSteppingAction = new G4MSSteppingAction();
 81   }                                                83   }
 82   StoreUserActions();                              84   StoreUserActions();
 83   DoScan();                                        85   DoScan();
 84   RestoreUserActions();                            86   RestoreUserActions();
 85 }                                                  87 }
 86                                                    88 
 87 // -------------------------------------------     89 // --------------------------------------------------------------------
 88 void G4MaterialScanner::StoreUserActions()         90 void G4MaterialScanner::StoreUserActions()
 89 {                                                  91 {
 90   theUserEventAction = theEventManager->GetUse <<  92   theUserEventAction    = theEventManager->GetUserEventAction();
 91   theUserStackingAction = theEventManager->Get     93   theUserStackingAction = theEventManager->GetUserStackingAction();
 92   theUserTrackingAction = theEventManager->Get     94   theUserTrackingAction = theEventManager->GetUserTrackingAction();
 93   theUserSteppingAction = theEventManager->Get     95   theUserSteppingAction = theEventManager->GetUserSteppingAction();
 94                                                    96 
 95   theEventManager->SetUserAction(theMatScanner     97   theEventManager->SetUserAction(theMatScannerEventAction);
 96   theEventManager->SetUserAction(theMatScanner     98   theEventManager->SetUserAction(theMatScannerStackingAction);
 97   theEventManager->SetUserAction(theMatScanner     99   theEventManager->SetUserAction(theMatScannerTrackingAction);
 98   theEventManager->SetUserAction(theMatScanner    100   theEventManager->SetUserAction(theMatScannerSteppingAction);
 99                                                   101 
100   G4SDManager* theSDMan = G4SDManager::GetSDMp    102   G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
101   if (theSDMan != nullptr) {                   << 103   if(theSDMan != nullptr)
                                                   >> 104   {
102     theSDMan->Activate("/", false);               105     theSDMan->Activate("/", false);
103   }                                               106   }
104                                                   107 
105   G4GeometryManager* theGeomMan = G4GeometryMa    108   G4GeometryManager* theGeomMan = G4GeometryManager::GetInstance();
106   theGeomMan->OpenGeometry();                     109   theGeomMan->OpenGeometry();
107   theGeomMan->CloseGeometry(true);                110   theGeomMan->CloseGeometry(true);
108 }                                                 111 }
109                                                   112 
110 // -------------------------------------------    113 // --------------------------------------------------------------------
111 void G4MaterialScanner::RestoreUserActions()      114 void G4MaterialScanner::RestoreUserActions()
112 {                                                 115 {
113   theEventManager->SetUserAction(theUserEventA    116   theEventManager->SetUserAction(theUserEventAction);
114   theEventManager->SetUserAction(theUserStacki    117   theEventManager->SetUserAction(theUserStackingAction);
115   theEventManager->SetUserAction(theUserTracki    118   theEventManager->SetUserAction(theUserTrackingAction);
116   theEventManager->SetUserAction(theUserSteppi    119   theEventManager->SetUserAction(theUserSteppingAction);
117                                                   120 
118   G4SDManager* theSDMan = G4SDManager::GetSDMp    121   G4SDManager* theSDMan = G4SDManager::GetSDMpointerIfExist();
119   if (theSDMan != nullptr) {                   << 122   if(theSDMan != nullptr)
                                                   >> 123   {
120     theSDMan->Activate("/", true);                124     theSDMan->Activate("/", true);
121   }                                               125   }
122 }                                                 126 }
123                                                   127 
124 // -------------------------------------------    128 // --------------------------------------------------------------------
125 void G4MaterialScanner::DoScan()                  129 void G4MaterialScanner::DoScan()
126 {                                                 130 {
127   // Confirm material table is updated            131   // Confirm material table is updated
128   G4RunManagerKernel::GetRunManagerKernel()->U    132   G4RunManagerKernel::GetRunManagerKernel()->UpdateRegion();
129                                                   133 
                                                   >> 134   /////  // Make sure Geantino has been initialized
                                                   >> 135   /////  G4ProcessVector* pVector
                                                   >> 136   /////    =
                                                   >> 137   /// G4Geantino::GeantinoDefinition()->GetProcessManager()->GetProcessList();
                                                   >> 138   /////  for (G4int j=0; j < pVector->size(); ++j) {
                                                   >> 139   ///// (*pVector)[j]->BuildPhysicsTable(*(G4Geantino::GeantinoDefinition()));
                                                   >> 140   /////  }
                                                   >> 141 
130   // Close geometry and set the application st    142   // Close geometry and set the application state
131   G4GeometryManager* geomManager = G4GeometryM    143   G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
132   geomManager->OpenGeometry();                    144   geomManager->OpenGeometry();
133   geomManager->CloseGeometry(true, false);     << 145   geomManager->CloseGeometry(1, 0);
134                                                   146 
135   G4ThreeVector center(0, 0, 0);                  147   G4ThreeVector center(0, 0, 0);
136   G4Navigator* navigator =                     << 148   G4Navigator* navigator = G4TransportationManager::GetTransportationManager()
137     G4TransportationManager::GetTransportation << 149                              ->GetNavigatorForTracking();
138   navigator->LocateGlobalPointAndSetup(center, << 150   navigator->LocateGlobalPointAndSetup(center, 0, false);
139                                                   151 
140   G4StateManager* theStateMan = G4StateManager    152   G4StateManager* theStateMan = G4StateManager::GetStateManager();
141   theStateMan->SetNewState(G4State_GeomClosed)    153   theStateMan->SetNewState(G4State_GeomClosed);
142                                                   154 
143   // Event loop                                   155   // Event loop
144   G4int iEvent = 0;                               156   G4int iEvent = 0;
145   for (G4int iTheta = 0; iTheta < nTheta; ++iT << 157   for(G4int iTheta = 0; iTheta < nTheta; ++iTheta)
                                                   >> 158   {
146     G4double theta = thetaMin;                    159     G4double theta = thetaMin;
147     if (iTheta > 0) theta += G4double(iTheta)  << 160     if(iTheta > 0)
                                                   >> 161       theta += G4double(iTheta) * thetaSpan / G4double(nTheta - 1);
148     G4double aveLength = 0.;                      162     G4double aveLength = 0.;
149     G4double aveX0 = 0.;                       << 163     G4double aveX0     = 0.;
150     G4double aveLambda = 0.;                      164     G4double aveLambda = 0.;
151     G4cout << G4endl;                             165     G4cout << G4endl;
152     G4cout << "         Theta(deg)    Phi(deg) << 166     G4cout
                                                   >> 167       << "         Theta(deg)    Phi(deg)  Length(mm)          x0     lambda0"
                                                   >> 168       << G4endl;
153     G4cout << G4endl;                             169     G4cout << G4endl;
154     for (G4int iPhi = 0; iPhi < nPhi; ++iPhi)  << 170     for(G4int iPhi = 0; iPhi < nPhi; ++iPhi)
155       auto anEvent = new G4Event(iEvent++);    << 171     {
156       G4double phi = phiMin;                   << 172       G4Event* anEvent = new G4Event(iEvent++);
157       if (iPhi > 0) phi += G4double(iPhi) * ph << 173       G4double phi     = phiMin;
158       eyeDirection = G4ThreeVector(std::cos(th << 174       if(iPhi > 0)
159                                    std::sin(th << 175         phi += G4double(iPhi) * phiSpan / G4double(nPhi - 1);
                                                   >> 176       eyeDirection =
                                                   >> 177         G4ThreeVector(std::cos(theta) * std::cos(phi),
                                                   >> 178                       std::cos(theta) * std::sin(phi), std::sin(theta));
160       theRayShooter->Shoot(anEvent, eyePositio    179       theRayShooter->Shoot(anEvent, eyePosition, eyeDirection);
161       theMatScannerSteppingAction->Initialize(    180       theMatScannerSteppingAction->Initialize(regionSensitive, theRegion);
162       theEventManager->ProcessOneEvent(anEvent    181       theEventManager->ProcessOneEvent(anEvent);
163       G4double length = theMatScannerSteppingA    182       G4double length = theMatScannerSteppingAction->GetTotalStepLength();
164       G4double x0 = theMatScannerSteppingActio << 183       G4double x0     = theMatScannerSteppingAction->GetX0();
165       G4double lambda = theMatScannerSteppingA    184       G4double lambda = theMatScannerSteppingAction->GetLambda0();
166                                                   185 
167       G4cout << "        " << std::setw(11) << << 186       G4cout << "        " << std::setw(11) << theta / deg << " "
168              << " " << std::setw(11) << length << 187              << std::setw(11) << phi / deg << " " << std::setw(11)
169              << std::setw(11) << lambda;       << 188              << length / mm << " " << std::setw(11) << x0 << " "
170       if(1 == verbosity)                       << 189              << std::setw(11) << lambda << G4endl;
171       {                                        << 
172         theMatScannerSteppingAction->PrintInte << 
173       }                                        << 
174       else if(2 == verbosity)                  << 
175       {                                        << 
176         theMatScannerSteppingAction->PrintEach << 
177       }                                        << 
178       G4cout << G4endl;                        << 
179       aveLength += length / mm;                   190       aveLength += length / mm;
180       aveX0 += x0;                                191       aveX0 += x0;
181       aveLambda += lambda;                        192       aveLambda += lambda;
182     }                                             193     }
183     if (nPhi > 1) {                            << 194     if(nPhi > 1)
                                                   >> 195     {
184       G4cout << G4endl;                           196       G4cout << G4endl;
185       G4cout << " ave. for theta = " << std::s << 197       G4cout << " ave. for theta = " << std::setw(11) << theta / deg << " : "
186              << aveLength / nPhi << " " << std << 198              << std::setw(11) << aveLength / nPhi << " " << std::setw(11)
187              << aveLambda / nPhi << G4endl;    << 199              << aveX0 / nPhi << " " << std::setw(11) << aveLambda / nPhi
                                                   >> 200              << G4endl;
188     }                                             201     }
189   }                                               202   }
190                                                   203 
191   theStateMan->SetNewState(G4State_Idle);         204   theStateMan->SetNewState(G4State_Idle);
192   return;                                         205   return;
193 }                                                 206 }
194                                                   207 
195 // -------------------------------------------    208 // --------------------------------------------------------------------
196 G4bool G4MaterialScanner::SetRegionName(const     209 G4bool G4MaterialScanner::SetRegionName(const G4String& val)
197 {                                                 210 {
198   G4Region* aRegion = G4RegionStore::GetInstan    211   G4Region* aRegion = G4RegionStore::GetInstance()->GetRegion(val);
199   if (aRegion != nullptr) {                    << 212   if(aRegion != nullptr)
200     theRegion = aRegion;                       << 213   {
                                                   >> 214     theRegion  = aRegion;
201     regionName = val;                             215     regionName = val;
202     return true;                                  216     return true;
203   }                                               217   }
204                                                << 218   else
205   G4cerr << "Region <" << val << "> not found. << 219   {
206   G4cerr << "Defined regions are : " << G4endl << 220     G4cerr << "Region <" << val << "> not found. Command ignored." << G4endl;
207   for (const auto& i : *G4RegionStore::GetInst << 221     G4cerr << "Defined regions are : " << G4endl;
208     G4cerr << " " << i->GetName();             << 222     for(std::size_t i = 0; i < G4RegionStore::GetInstance()->size(); ++i)
                                                   >> 223     {
                                                   >> 224       G4cerr << " " << (*(G4RegionStore::GetInstance()))[i]->GetName();
                                                   >> 225     }
                                                   >> 226     G4cerr << G4endl;
                                                   >> 227     return false;
209   }                                               228   }
210   G4cerr << G4endl;                            << 
211   return false;                                << 
212 }                                                 229 }
213                                                   230