Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/solidstate/channeling/src/G4ChannelingOptrChangeCrossSection.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/solidstate/channeling/src/G4ChannelingOptrChangeCrossSection.cc (Version 11.3.0) and /processes/solidstate/channeling/src/G4ChannelingOptrChangeCrossSection.cc (Version 11.1.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 #include "G4ChannelingOptrChangeCrossSection.h     26 #include "G4ChannelingOptrChangeCrossSection.hh"
 27 #include "G4BiasingProcessInterface.hh"            27 #include "G4BiasingProcessInterface.hh"
 28 #include "G4BOptnChangeCrossSection.hh"            28 #include "G4BOptnChangeCrossSection.hh"
 29                                                    29 
 30 #include "G4ParticleDefinition.hh"                 30 #include "G4ParticleDefinition.hh"
 31 #include "G4ParticleTable.hh"                      31 #include "G4ParticleTable.hh"
 32 #include "G4VProcess.hh"                           32 #include "G4VProcess.hh"
 33                                                    33 
 34 #include "Randomize.hh"                            34 #include "Randomize.hh"
 35                                                    35 
 36 #include "G4InteractionLawPhysical.hh"             36 #include "G4InteractionLawPhysical.hh"
 37                                                    37 
 38 #include "G4ChannelingTrackData.hh"                38 #include "G4ChannelingTrackData.hh"
 39 #include "G4EmProcessSubType.hh"                   39 #include "G4EmProcessSubType.hh"
 40 #include "G4PhysicsModelCatalog.hh"                40 #include "G4PhysicsModelCatalog.hh"
 41                                                    41 
 42 //....oooOO0OOooo........oooOO0OOooo........oo     42 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 43                                                    43 
 44 G4ChannelingOptrChangeCrossSection::G4Channeli <<  44 G4ChannelingOptrChangeCrossSection::G4ChannelingOptrChangeCrossSection(G4String particleName,
 45                                                <<  45                                                                        G4String         name)
 46   :G4VBiasingOperator(name),                   <<  46 :G4VBiasingOperator(name),
 47 fChannelingID(G4PhysicsModelCatalog::GetModelI     47 fChannelingID(G4PhysicsModelCatalog::GetModelID("model_channeling")),
 48 fSetup(true){                                      48 fSetup(true){
 49     fParticleToBias = G4ParticleTable::GetPart     49     fParticleToBias = G4ParticleTable::GetParticleTable()->FindParticle(particleName);
 50                                                    50     
 51     if ( fParticleToBias == 0 )                    51     if ( fParticleToBias == 0 )
 52     {                                              52     {
 53         G4ExceptionDescription ed;                 53         G4ExceptionDescription ed;
 54         ed << "Particle `" << particleName <<      54         ed << "Particle `" << particleName << "' not found !" << G4endl;
 55         G4Exception("G4ChannelingOptrChangeCro     55         G4Exception("G4ChannelingOptrChangeCrossSection(...)",
 56                     "G4Channeling",                56                     "G4Channeling",
 57                     JustWarning,                   57                     JustWarning,
 58                     ed);                           58                     ed);
 59     }                                              59     }
 60                                                    60     
 61     fProcessToDensity["channeling"] = fDensity     61     fProcessToDensity["channeling"] = fDensityRatioNone;
 62 }                                                  62 }
 63                                                    63 
 64 //....oooOO0OOooo........oooOO0OOooo........oo     64 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 65                                                    65 
 66 G4ChannelingOptrChangeCrossSection::~G4Channel     66 G4ChannelingOptrChangeCrossSection::~G4ChannelingOptrChangeCrossSection(){
 67     for ( std::map< const G4BiasingProcessInte     67     for ( std::map< const G4BiasingProcessInterface*, G4BOptnChangeCrossSection* >::iterator
 68          it = fChangeCrossSectionOperations.be     68          it = fChangeCrossSectionOperations.begin() ;
 69          it != fChangeCrossSectionOperations.e     69          it != fChangeCrossSectionOperations.end() ;
 70          it++ ) delete (*it).second;               70          it++ ) delete (*it).second;
 71 }                                                  71 }
 72                                                    72 
 73 //....oooOO0OOooo........oooOO0OOooo........oo     73 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 74                                                    74 
 75 void G4ChannelingOptrChangeCrossSection::Start     75 void G4ChannelingOptrChangeCrossSection::StartRun(){
 76     if ( fSetup ){                                 76     if ( fSetup ){
 77         const G4ProcessManager* processManager     77         const G4ProcessManager* processManager = fParticleToBias->GetProcessManager();
 78         const G4BiasingProcessSharedData* shar     78         const G4BiasingProcessSharedData* sharedData =
 79         G4BiasingProcessInterface::GetSharedDa     79         G4BiasingProcessInterface::GetSharedData( processManager );
 80         if ( sharedData ){                         80         if ( sharedData ){
 81             for ( size_t i = 0 ; i < (sharedDa     81             for ( size_t i = 0 ; i < (sharedData->GetPhysicsBiasingProcessInterfaces()).size(); i++ ){
 82                 const G4BiasingProcessInterfac     82                 const G4BiasingProcessInterface* wrapperProcess =
 83                 (sharedData->GetPhysicsBiasing     83                 (sharedData->GetPhysicsBiasingProcessInterfaces())[i];
 84                 const G4String& processName =  <<  84                 G4String processName = wrapperProcess->GetWrappedProcess()->GetProcessName();
 85                 const G4String& operationName  <<  85                 G4String operationName = "channelingChangeXS-" + processName;
 86                 fChangeCrossSectionOperations[     86                 fChangeCrossSectionOperations[wrapperProcess] =
 87       new G4BOptnChangeCrossSection(operationN <<  87                 new G4BOptnChangeCrossSection(operationName);
 88                                                    88                 
 89                 G4ProcessType type = wrapperPr     89                 G4ProcessType type = wrapperProcess->GetWrappedProcess()->GetProcessType();
 90                 G4int subType = wrapperProcess     90                 G4int subType = wrapperProcess->GetWrappedProcess()->GetProcessSubType();
 91                                                    91 
 92                 switch (type) {                    92                 switch (type) {
 93                     case fNotDefined:              93                     case fNotDefined:
 94                         fProcessToDensity[proc     94                         fProcessToDensity[processName] = fDensityRatioNotDefined;
 95                         break;                     95                         break;
 96                     case fTransportation:          96                     case fTransportation:
 97                         fProcessToDensity[proc     97                         fProcessToDensity[processName] = fDensityRatioNone;
 98                         break;                     98                         break;
 99                     case fElectromagnetic:         99                     case fElectromagnetic:
100                         if(subType == fCoulomb    100                         if(subType == fCoulombScattering ||
101                            subType == fMultipl    101                            subType == fMultipleScattering){
102                             fProcessToDensity[    102                             fProcessToDensity[processName] = fDensityRatioNuD;
103                         }                         103                         }
104                         if(subType == fIonisat    104                         if(subType == fIonisation ||
105                            subType == fPairPro    105                            subType == fPairProdByCharged ||
106                            subType == fAnnihil    106                            subType == fAnnihilation ||
107                            subType == fAnnihil    107                            subType == fAnnihilationToMuMu ||
108                            subType == fAnnihil    108                            subType == fAnnihilationToHadrons){
109                             fProcessToDensity[    109                             fProcessToDensity[processName] = fDensityRatioElD;
110                         }                         110                         }
111                         if(subType == fBremsst    111                         if(subType == fBremsstrahlung ||
112                            subType == fNuclear    112                            subType == fNuclearStopping){
113                             fProcessToDensity[    113                             fProcessToDensity[processName] = fDensityRatioNuDElD;
114                         }                         114                         }
115                                                   115                         
116                         if(subType == fCerenko    116                         if(subType == fCerenkov ||
117                            subType == fScintil    117                            subType == fScintillation ||
118                            subType == fSynchro    118                            subType == fSynchrotronRadiation ||
119                            subType == fTransit    119                            subType == fTransitionRadiation){
120                             fProcessToDensity[    120                             fProcessToDensity[processName] = fDensityRatioNone;
121                         }                         121                         }
122                         if(subType == fRayleig    122                         if(subType == fRayleigh ||
123                            subType == fPhotoEl    123                            subType == fPhotoElectricEffect ||
124                            subType == fCompton    124                            subType == fComptonScattering ||
125                            subType == fGammaCo    125                            subType == fGammaConversion ||
126                            subType == fGammaCo    126                            subType == fGammaConversionToMuMu){
127                             fProcessToDensity[    127                             fProcessToDensity[processName] = fDensityRatioNone;
128                         }                         128                         }
129                         break;                    129                         break;
130                     case fOptical:                130                     case fOptical:
131                         fProcessToDensity[proc    131                         fProcessToDensity[processName] = fDensityRatioNone;
132                         break;                    132                         break;
133                     case fHadronic:               133                     case fHadronic:
134                         fProcessToDensity[proc    134                         fProcessToDensity[processName] = fDensityRatioNuD;
135                         break;                    135                         break;
136                     case fPhotolepton_hadron:     136                     case fPhotolepton_hadron:
137                         fProcessToDensity[proc    137                         fProcessToDensity[processName] = fDensityRatioNuD;
138                         break;                    138                         break;
139                     case fGeneral:                139                     case fGeneral:
140                         fProcessToDensity[proc    140                         fProcessToDensity[processName] = fDensityRatioNone;
141                         break;                    141                         break;
142                     case fDecay:                  142                     case fDecay:
143                         fProcessToDensity[proc    143                         fProcessToDensity[processName] = fDensityRatioNone;
144                         break;                    144                         break;
145                     case fParameterisation:       145                     case fParameterisation:
146                         fProcessToDensity[proc    146                         fProcessToDensity[processName] = fDensityRatioNone;
147                         break;                    147                         break;
148                     case fUserDefined:            148                     case fUserDefined:
149                         fProcessToDensity[proc    149                         fProcessToDensity[processName] = fDensityRatioNone;
150                         break;                    150                         break;
151                     case fParallel:               151                     case fParallel:
152                         fProcessToDensity[proc    152                         fProcessToDensity[processName] = fDensityRatioNone;
153                         break;                    153                         break;
154                     case fPhonon:                 154                     case fPhonon:
155                         fProcessToDensity[proc    155                         fProcessToDensity[processName] = fDensityRatioNone;
156                         break;                    156                         break;
157                     case fUCN:                    157                     case fUCN:
158                         fProcessToDensity[proc    158                         fProcessToDensity[processName] = fDensityRatioNone;
159                         break;                    159                         break;
160                     default:                      160                     default:
161                         fProcessToDensity[proc    161                         fProcessToDensity[processName] = fDensityRatioNone;
162                         break;                    162                         break;
163                 }                                 163                 }
164             }                                     164             }
165         }                                         165         }
166         fSetup = false;                           166         fSetup = false;
167     }                                             167     }
168 }                                                 168 }
169                                                   169 
170 //....oooOO0OOooo........oooOO0OOooo........oo    170 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
171                                                   171 
172 G4VBiasingOperation*                              172 G4VBiasingOperation*
173 G4ChannelingOptrChangeCrossSection::ProposeOcc    173 G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(const G4Track*            track,
174                                                   174                                                                      const G4BiasingProcessInterface*
175                                                   175                                                                      callingProcess)
176 {                                                 176 {
177     if ( track->GetDefinition() != fParticleTo    177     if ( track->GetDefinition() != fParticleToBias ) return 0;
178                                                   178     
179     G4double analogInteractionLength =            179     G4double analogInteractionLength =
180     callingProcess->GetWrappedProcess()->GetCu    180     callingProcess->GetWrappedProcess()->GetCurrentInteractionLength();
181     if ( analogInteractionLength > DBL_MAX/10.    181     if ( analogInteractionLength > DBL_MAX/10. ) return 0;
182                                                   182     
183     G4double analogXS = 1./analogInteractionLe    183     G4double analogXS = 1./analogInteractionLength;
184                                                   184     
185     G4ChannelingTrackData* trackdata =            185     G4ChannelingTrackData* trackdata =
186     (G4ChannelingTrackData*)(track->GetAuxilia    186     (G4ChannelingTrackData*)(track->GetAuxiliaryTrackInformation(fChannelingID));
187     if(trackdata==nullptr) return 0;              187     if(trackdata==nullptr) return 0;
188                                                   188     
189     G4double XStransformation = 1.;               189     G4double XStransformation = 1.;
190     auto search = fProcessToDensity.find(calli    190     auto search = fProcessToDensity.find(callingProcess->GetWrappedProcess()->GetProcessName());
191     if(search != fProcessToDensity.end()) {       191     if(search != fProcessToDensity.end()) {
192         switch (search->second) {                 192         switch (search->second) {
193             case fDensityRatioNuDElD:             193             case fDensityRatioNuDElD:
194                 XStransformation = trackdata->    194                 XStransformation = trackdata->GetDensity();
195                 break;                            195                 break;
196             case fDensityRatioNuD:                196             case fDensityRatioNuD:
197                 XStransformation = trackdata->    197                 XStransformation = trackdata->GetNuD();
198                 break;                            198                 break;
199             case fDensityRatioElD:                199             case fDensityRatioElD:
200                 XStransformation = trackdata->    200                 XStransformation = trackdata->GetElD();
201                 break;                            201                 break;
202             case fDensityRatioNone:               202             case fDensityRatioNone:
203                 return 0;                         203                 return 0;
204                 break;                            204                 break;
205             case fDensityRatioNotDefined:         205             case fDensityRatioNotDefined:
206                 return 0;                         206                 return 0;
207                 break;                            207                 break;
208             default:                              208             default:
209                 return 0;                         209                 return 0;
210                 break;                            210                 break;
211         }                                         211         }
212     }                                             212     }
213     else{                                         213     else{
214         XStransformation = trackdata->GetDensi    214         XStransformation = trackdata->GetDensity();
215     }                                             215     }
216                                                   216 
217     G4BOptnChangeCrossSection*   operation = f    217     G4BOptnChangeCrossSection*   operation = fChangeCrossSectionOperations[callingProcess];
218     G4VBiasingOperation* previousOperation = c    218     G4VBiasingOperation* previousOperation = callingProcess->GetPreviousOccurenceBiasingOperation();
219                                                   219     
220     if ( previousOperation == 0 ){                220     if ( previousOperation == 0 ){
221         operation->SetBiasedCrossSection( XStr    221         operation->SetBiasedCrossSection( XStransformation * analogXS );
222         operation->Sample();                      222         operation->Sample();
223     }                                             223     }
224     else{                                         224     else{
225         if (  previousOperation != operation )    225         if (  previousOperation != operation ){
226             G4ExceptionDescription ed;            226             G4ExceptionDescription ed;
227             ed << " Logic problem in operation    227             ed << " Logic problem in operation handling !" << G4endl;
228             G4Exception("G4ChannelingOptrChang    228             G4Exception("G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(...)",
229                         "G4Channeling",           229                         "G4Channeling",
230                         JustWarning,              230                         JustWarning,
231                         ed);                      231                         ed);
232             return 0;                             232             return 0;
233         }                                         233         }
234         if ( operation->GetInteractionOccured(    234         if ( operation->GetInteractionOccured() ){
235             operation->SetBiasedCrossSection(     235             operation->SetBiasedCrossSection( XStransformation * analogXS );
236             operation->Sample();                  236             operation->Sample();
237         }                                         237         }
238         else{                                     238         else{
239             operation->UpdateForStep( callingP    239             operation->UpdateForStep( callingProcess->GetPreviousStepSize() );
240             operation->SetBiasedCrossSection(     240             operation->SetBiasedCrossSection( XStransformation * analogXS );
241             operation->UpdateForStep( 0.0 );      241             operation->UpdateForStep( 0.0 );
242         }                                         242         }
243     }                                             243     }
244                                                   244     
245     return operation;                             245     return operation;
246                                                   246     
247 }                                                 247 }
248                                                   248 
249 //....oooOO0OOooo........oooOO0OOooo........oo    249 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
250                                                   250 
251 void G4ChannelingOptrChangeCrossSection::         251 void G4ChannelingOptrChangeCrossSection::
252 OperationApplied(const G4BiasingProcessInterfa    252 OperationApplied(const G4BiasingProcessInterface*           callingProcess,
253                  G4BiasingAppliedCase,            253                  G4BiasingAppliedCase,
254                  G4VBiasingOperation*             254                  G4VBiasingOperation*             occurenceOperationApplied,
255                  G4double,                        255                  G4double,
256                  G4VBiasingOperation*,            256                  G4VBiasingOperation*,
257                  const G4VParticleChange*         257                  const G4VParticleChange*                                  )
258 {                                                 258 {
259     G4BOptnChangeCrossSection* operation = fCh    259     G4BOptnChangeCrossSection* operation = fChangeCrossSectionOperations[callingProcess];
260     if ( operation ==  occurenceOperationAppli    260     if ( operation ==  occurenceOperationApplied ) operation->SetInteractionOccured();
261 }                                                 261 }
262                                                   262 
263 //....oooOO0OOooo........oooOO0OOooo........oo    263 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
264                                                   264