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 9.0.p1)


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