Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/biasing/generic/src/G4BiasingHelper.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 /processes/biasing/generic/src/G4BiasingHelper.cc (Version 11.3.0) and /processes/biasing/generic/src/G4BiasingHelper.cc (Version 10.7)


  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 // G4BiasingHelper                             << 
 27 // ------------------------------------------- << 
 28 #include "G4BiasingHelper.hh"                      26 #include "G4BiasingHelper.hh"
 29                                                    27 
 30 #include "G4ProcessManager.hh"                     28 #include "G4ProcessManager.hh"
 31 #include "G4BiasingProcessInterface.hh"            29 #include "G4BiasingProcessInterface.hh"
 32 #include "G4ParallelGeometriesLimiterProcess.h     30 #include "G4ParallelGeometriesLimiterProcess.hh"
 33                                                    31 
 34 G4bool G4BiasingHelper::ActivatePhysicsBiasing     32 G4bool G4BiasingHelper::ActivatePhysicsBiasing(G4ProcessManager* pmanager,
 35                  const G4String& physicsProces <<  33                  G4String physicsProcessToBias,
 36                  const G4String& wrappedName)  <<  34                  G4String wrappedName)
 37 {                                                  35 {
 38   G4VProcess* physicsProcess(0);                   36   G4VProcess* physicsProcess(0);
 39                                                    37   
 40   G4ProcessVector* vprocess = pmanager->GetPro     38   G4ProcessVector* vprocess = pmanager->GetProcessList();
 41   for (auto ip = 0 ; ip < (G4int)vprocess->siz <<  39   for (std::size_t ip = 0 ; ip < vprocess->size() ; ++ip)
 42   {                                            << 
 43     if ( (*vprocess)[ip]->GetProcessName() ==  << 
 44     {                                              40     {
 45       physicsProcess = (*vprocess)[ip];        <<  41       if ( (*vprocess)[ip]->GetProcessName() == physicsProcessToBias )
 46       break;                                   <<  42   {
                                                   >>  43     physicsProcess = (*vprocess)[ip];
                                                   >>  44     break;
                                                   >>  45   }
 47     }                                              46     }
 48   }                                            << 
 49                                                    47   
 50   // -- process not found, return "false" to t     48   // -- process not found, return "false" to tell about failure
 51   if ( physicsProcess == nullptr ) return fals <<  49   if ( physicsProcess == 0 ) return false;
 52                                                    50   
 53   // -- process is not a physics one, return "     51   // -- process is not a physics one, return "false" to tell about failure
 54   G4int processType = physicsProcess->GetProce     52   G4int processType = physicsProcess->GetProcessType();
 55   if ( ( processType != 2 ) &&  // EM              53   if ( ( processType != 2 ) &&  // EM
 56        ( processType != 3 ) &&  // Optical         54        ( processType != 3 ) &&  // Optical
 57        ( processType != 4 ) &&  // Hadronic        55        ( processType != 4 ) &&  // Hadronic
 58        ( processType != 6 ) )   // Decay           56        ( processType != 6 ) )   // Decay
 59     return false;                                  57     return false;
 60                                                    58 
 61   // -- prevent wrapper of wrapper...              59   // -- prevent wrapper of wrapper...
 62   if ( dynamic_cast< G4BiasingProcessInterface <<  60   if ( dynamic_cast< G4BiasingProcessInterface* >( physicsProcess ) ) return false;
 63     return false;                              << 
 64                                                    61 
 65   // -- remember process indeces:                  62   // -- remember process indeces:
 66   G4int atRestIndex = pmanager->GetProcessOrde <<  63   G4int    atRestIndex = pmanager->GetProcessOrdering(physicsProcess, idxAtRest   );
 67   G4int alongStepIndex = pmanager->GetProcessO     64   G4int alongStepIndex = pmanager->GetProcessOrdering(physicsProcess, idxAlongStep);
 68   G4int postStepIndex = pmanager->GetProcessOr <<  65   G4int  postStepIndex = pmanager->GetProcessOrdering(physicsProcess, idxPostStep );
 69                                                    66 
 70   // -- now remove the physic process, that wi     67   // -- now remove the physic process, that will be replaced by a wrapped version:
 71   G4VProcess* removed = pmanager->RemoveProces     68   G4VProcess* removed = pmanager->RemoveProcess(physicsProcess);
 72   if ( removed != physicsProcess )                 69   if ( removed != physicsProcess )
 73   {                                            <<  70     {
 74     G4ExceptionDescription ed;                 <<  71       G4ExceptionDescription ed;
 75     ed << "Internal inconsistency in processes <<  72       ed << "Internal inconsistency in processes handling. Please report !" << G4endl;
 76     G4Exception("G4BiasingHelper::ActivatePhys <<  73       G4Exception("G4BiasingHelper::ActivatePhysicsBiasing(...)",
 77                 "BIAS.GEN.01", FatalException, <<  74       "BIAS.GEN.01",
 78   }                                            <<  75       FatalException,
 79                                                <<  76       ed);
 80   G4BiasingProcessInterface* biasingWrapper =  <<  77     }
 81     new G4BiasingProcessInterface( physicsProc <<  78   
 82                                    atRestIndex <<  79   G4BiasingProcessInterface* biasingWrapper = new G4BiasingProcessInterface( physicsProcess,
 83                                    alongStepIn <<  80                        atRestIndex    != ordInActive,
 84                                    postStepInd <<  81                        alongStepIndex != ordInActive,
 85                                    wrappedName <<  82                        postStepIndex  != ordInActive,
                                                   >>  83                        wrappedName);
 86                                                    84 
 87   if ( alongStepIndex == -1 ) alongStepIndex =     85   if ( alongStepIndex == -1 ) alongStepIndex = ordDefault;
 88                                                    86   
 89   pmanager->AddProcess( biasingWrapper, atRest <<  87   pmanager->AddProcess( biasingWrapper,
                                                   >>  88       atRestIndex,
                                                   >>  89       alongStepIndex,
                                                   >>  90       postStepIndex);
 90                                                    91 
 91   return true;                                     92   return true;
 92 }                                                  93 }
 93                                                    94 
 94 void G4BiasingHelper::ActivateNonPhysicsBiasin     95 void G4BiasingHelper::ActivateNonPhysicsBiasing(G4ProcessManager* pmanager,
 95                                      const G4S <<  96             G4String nonPhysicsProcessName )
 96 {                                                  97 {
 97   G4BiasingProcessInterface* biasingNonPhys(nu <<  98   G4BiasingProcessInterface* biasingNonPhys(0);
 98   if ( nonPhysicsProcessName == "" )           <<  99   if ( nonPhysicsProcessName == "" ) biasingNonPhys = new G4BiasingProcessInterface();
 99     biasingNonPhys = new G4BiasingProcessInter << 100   else                               biasingNonPhys = new G4BiasingProcessInterface(nonPhysicsProcessName );
100   else                                         << 101   pmanager->AddProcess( biasingNonPhys,
101     biasingNonPhys = new G4BiasingProcessInter << 102       ordInActive,
102                                                << 103       ordInActive,
103   pmanager->AddProcess( biasingNonPhys, ordInA << 104       ordDefault);
104 }                                                 105 }
105                                                   106 
106 G4ParallelGeometriesLimiterProcess*            << 107 G4ParallelGeometriesLimiterProcess* G4BiasingHelper::AddLimiterProcess(G4ProcessManager* pmanager, const G4String& processName)
107 G4BiasingHelper::AddLimiterProcess(G4ProcessMa << 
108                                    const G4Str << 
109 {                                                 108 {
110   G4ParallelGeometriesLimiterProcess* toReturn    109   G4ParallelGeometriesLimiterProcess* toReturn = nullptr;
111                                                   110   
112   G4ProcessVector* processList = pmanager->Get    111   G4ProcessVector* processList = pmanager->GetProcessList();
113   G4bool noInstance = true;                       112   G4bool noInstance = true;
114   for (auto i = 0 ; i < (G4int)processList->si << 113   for (std::size_t i = 0 ; i < processList->size() ; ++i)
115   {                                            << 
116     G4VProcess* process = (*processList)[i];   << 
117     if ( dynamic_cast< G4ParallelGeometriesLim << 
118     {                                             114     {
119       noInstance = false;                      << 115       G4VProcess* process = (*processList)[i];
                                                   >> 116       if ( dynamic_cast< G4ParallelGeometriesLimiterProcess* >( process ) )
                                                   >> 117   {
                                                   >> 118     noInstance = false;
120                                                   119     
121       G4ExceptionDescription ed;               << 120     G4ExceptionDescription ed;
122       ed << "Trying to re-add a G4ParallelGeom << 121     ed << "Trying to re-add a G4ParallelGeometriesLimiterProcess process to the process manager for '"<<
123          << "to the process manager for '"     << 122       pmanager->GetParticleType()->GetParticleName() << " (PDG : " <<  pmanager->GetParticleType()->GetPDGEncoding() << " )"
124          << pmanager->GetParticleType()->GetPa << 123        << " while one is already present." << G4endl;
125          << " (PDG : " << pmanager->GetParticl << 124     G4Exception("G4BiasingHelper::AddBiasingProcessLimiter(G4ProcessManager* pmanager)",
126          << " while one is already present." < << 125           "BIAS.GEN.28",
127       G4Exception("G4BiasingHelper::AddBiasing << 126           JustWarning, ed,
128                   "BIAS.GEN.28", JustWarning,  << 127           "Call ignored.");
129       break;                                   << 128     break;
                                                   >> 129   }
130     }                                             130     }
131   }                                            << 
132                                                   131   
133   if ( noInstance )                               132   if ( noInstance )
134   {                                            << 133     {
135     G4ParallelGeometriesLimiterProcess* biasin << 134       G4ParallelGeometriesLimiterProcess* biasingLimiter = new G4ParallelGeometriesLimiterProcess(processName);
136     pmanager->AddProcess                ( bias << 135       pmanager->AddProcess                ( biasingLimiter );
137     pmanager->SetProcessOrderingToSecond( bias << 136       pmanager->SetProcessOrderingToSecond( biasingLimiter, idxAlongStep );
138     pmanager->SetProcessOrderingToLast  ( bias << 137       pmanager->SetProcessOrderingToLast  ( biasingLimiter, idxPostStep  );
139                                                   138       
140     toReturn = biasingLimiter;                 << 139       toReturn = biasingLimiter;
141   }                                            << 140     }
142                                                   141   
143   return toReturn;                                142   return toReturn;
                                                   >> 143   
144 }                                                 144 }
145                                                   145