Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/extended/biasing/ReverseMC01/src/G4AdjointPhysicsMessenger.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 /examples/extended/biasing/ReverseMC01/src/G4AdjointPhysicsMessenger.cc (Version 11.3.0) and /examples/extended/biasing/ReverseMC01/src/G4AdjointPhysicsMessenger.cc (Version 9.3.p2)


  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 /// \file biasing/ReverseMC01/src/G4AdjointPhy <<  26 // $Id: G4AdjointPhysicsMessenger.cc,v 1.1 2009/11/19 22:41:18 ldesorgh Exp $
 27 /// \brief Implementation of the G4AdjointPhys <<  27 // GEANT4 tag $Name: geant4-09-03-patch-02 $
 28 //                                             << 
 29 //                                                 28 //
 30 //////////////////////////////////////////////     29 //////////////////////////////////////////////////////////////
 31 //      Class Name:        G4AdjointPhysicsMes <<  30 //      Class Name: G4AdjointPhysicsMessenger
 32 //        Author:               L. Desorgher   <<  31 //  Author:         L. Desorgher
 33 //         Organisation:         SpaceIT GmbH  <<  32 //  Organisation:   SpaceIT GmbH
 34 //        Contract:        ESA contract 21435/ <<  33 //  Contract: ESA contract 21435/08/NL/AT
 35 //         Customer:             ESA/ESTEC     <<  34 //  Customer:       ESA/ESTEC
 36 //////////////////////////////////////////////     35 //////////////////////////////////////////////////////////////
 37                                                << 
 38 //....oooOO0OOooo........oooOO0OOooo........oo << 
 39 //....oooOO0OOooo........oooOO0OOooo........oo << 
 40                                                << 
 41 #include "G4AdjointPhysicsMessenger.hh"            36 #include "G4AdjointPhysicsMessenger.hh"
 42                                                <<  37 #include "G4UIdirectory.hh"
 43 #include "G4AdjointPhysicsList.hh"             << 
 44 #include "G4UIcmdWith3VectorAndUnit.hh"        << 
 45 #include "G4UIcmdWithABool.hh"                     38 #include "G4UIcmdWithABool.hh"
 46 #include "G4UIcmdWithADouble.hh"               << 
 47 #include "G4UIcmdWithADoubleAndUnit.hh"        << 
 48 #include "G4UIcmdWithAString.hh"               << 
 49 #include "G4UIcmdWithAnInteger.hh"                 39 #include "G4UIcmdWithAnInteger.hh"
                                                   >>  40 #include "G4UIcmdWithADoubleAndUnit.hh"
                                                   >>  41 #include "G4UIcmdWithADouble.hh"
 50 #include "G4UIcmdWithoutParameter.hh"              42 #include "G4UIcmdWithoutParameter.hh"
 51 #include "G4UIdirectory.hh"                    <<  43 #include "G4UIcmdWithAString.hh"
 52 #include "G4UnitsTable.hh"                         44 #include "G4UnitsTable.hh"
                                                   >>  45 #include "G4AdjointPhysicsList.hh"
                                                   >>  46 #include "G4UIcmdWith3VectorAndUnit.hh"
                                                   >>  47 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                   >>  48 //
                                                   >>  49 G4AdjointPhysicsMessenger::G4AdjointPhysicsMessenger(
                                                   >>  50                                            G4AdjointPhysicsList* pPhysicsList)
                                                   >>  51 :thePhysicsList(pPhysicsList)
                                                   >>  52 { 
                                                   >>  53   PhysicsDir = new G4UIdirectory("/adjoint_physics/");
                                                   >>  54   PhysicsDir->SetGuidance("Definition of physics processes to be used in the adjoint and forward simulation mode");
                                                   >>  55  
                                                   >>  56   
                                                   >>  57   
                                                   >>  58   
 53                                                    59 
 54 //....oooOO0OOooo........oooOO0OOooo........oo << 
 55                                                    60 
 56 G4AdjointPhysicsMessenger::G4AdjointPhysicsMes <<  61   //Physics
 57   : G4UImessenger(),                           << 
 58     fPhysicsList(pPhysicsList),                << 
 59     fPhysicsDir(0),                            << 
 60     fUsepIonisationCmd(0),                     << 
 61     fUseBremCmd(0),                            << 
 62     fUseComptonCmd(0),                         << 
 63     fUseMSCmd(0),                              << 
 64     fUsePEEffectCmd(0),                        << 
 65     fUseGammaConversionCmd(0),                 << 
 66     fUseEgainFluctuationCmd(0),                << 
 67     fSetEminAdjModelsCmd(0),                   << 
 68     fSetEmaxAdjModelsCmd(0)                    << 
 69 {                                              << 
 70   fPhysicsDir = new G4UIdirectory("/adjoint_ph << 
 71                                                << 
 72   fPhysicsDir->SetGuidance("Definition of adjo << 
 73   //-------                                        62   //-------
 74   fUsepIonisationCmd = new G4UIcmdWithABool("/ <<  63   
 75   fUsepIonisationCmd->SetGuidance("If true (fa <<  64  /* UseIonisationCmd = new G4UIcmdWithABool("/adjoint_physics/UseElectronIonisation",this);
 76   fUsepIonisationCmd->AvailableForStates(G4Sta <<  65   UseIonisationCmd->SetGuidance("If true (false) the ionisation is (not) considered for both adjoint and forward simulations");
 77                                                <<  66   UseIonisationCmd->AvailableForStates(G4State_PreInit);
 78   fUseBremCmd = new G4UIcmdWithABool("/adjoint <<  67  */ 
 79   fUseBremCmd->SetGuidance("If true (false) th <<  68   
 80   fUseBremCmd->AvailableForStates(G4State_PreI <<  69   UsepIonisationCmd = new G4UIcmdWithABool("/adjoint_physics/UseProtonIonisation",this);
 81                                                <<  70   UsepIonisationCmd->SetGuidance("If true (false) the proton ionisation is (not) considered for both adjoint and forward simulations");
 82   fUseComptonCmd = new G4UIcmdWithABool("/adjo <<  71   UsepIonisationCmd->AvailableForStates(G4State_PreInit);
 83   fUseComptonCmd->SetGuidance("If true (false) <<  72   
 84   fUseComptonCmd->AvailableForStates(G4State_P <<  73   UseBremCmd = new G4UIcmdWithABool("/adjoint_physics/UseBremsstrahlung",this);
 85                                                <<  74   UseBremCmd->SetGuidance("If true (false) the bremsstrahlung process is (not) considered for both adjoint and forward simulations");
 86   fUseMSCmd = new G4UIcmdWithABool("/adjoint_p <<  75   UseBremCmd->AvailableForStates(G4State_PreInit); 
 87   fUseMSCmd->SetGuidance("If true (false) the  <<  76   
 88   fUseMSCmd->AvailableForStates(G4State_PreIni <<  77   UseComptonCmd = new G4UIcmdWithABool("/adjoint_physics/UseCompton",this);
 89                                                <<  78   UseComptonCmd->SetGuidance("If true (false) the Compton scattering is (not) considered for both adjoint and forward simulations");
 90   fUseEgainFluctuationCmd = new G4UIcmdWithABo <<  79   UseComptonCmd->AvailableForStates(G4State_PreInit);  
 91   fUseEgainFluctuationCmd->SetGuidance(        <<  80   
 92     "Switch on/off the fluctation for continuo <<  81   UseMSCmd = new G4UIcmdWithABool("/adjoint_physics/UseMS",this);
 93   fUseEgainFluctuationCmd->AvailableForStates( <<  82   UseMSCmd->SetGuidance("If true (false) the continuous multiple scattering is (not) considered for both adjoint and forward simulations");
 94                                                <<  83   UseMSCmd->AvailableForStates(G4State_PreInit); 
 95   fUsePEEffectCmd = new G4UIcmdWithABool("/adj <<  84   
 96   fUsePEEffectCmd->AvailableForStates(G4State_ <<  85   UseEgainFluctuationCmd = new G4UIcmdWithABool("/adjoint_physics/UseEgainElossFluctuation",this);
 97   fUsePEEffectCmd->SetGuidance("If true (false <<  86   UseEgainFluctuationCmd->SetGuidance("If true (false) the fluctation for continuous energy gain and loss is (not) considered for adjoint and forward simulations");
 98                                                <<  87   UseEgainFluctuationCmd->AvailableForStates(G4State_PreInit); 
 99   fUseGammaConversionCmd = new G4UIcmdWithABoo <<  88   
100   fUseGammaConversionCmd->AvailableForStates(G <<  89   UsePEEffectCmd = new G4UIcmdWithABool("/adjoint_physics/UsePEEffect",this);
101   fUseGammaConversionCmd->SetGuidance("If true <<  90   UsePEEffectCmd->AvailableForStates(G4State_PreInit); 
102                                                <<  91   UsePEEffectCmd->SetGuidance("If true (false) the photo electric effect is (not) considered for the adjoint and forward simulations");
103   fSetEminAdjModelsCmd =                       <<  92    
104     new G4UIcmdWithADoubleAndUnit("/adjoint_ph <<  93   UseGammaConversionCmd = new G4UIcmdWithABool("/adjoint_physics/UseGammaConversion",this);
105   fSetEminAdjModelsCmd->SetGuidance("Set the m <<  94   UseGammaConversionCmd->AvailableForStates(G4State_PreInit);
106   fSetEminAdjModelsCmd->SetParameterName("Emin <<  95   UseGammaConversionCmd->SetGuidance("If true the gamma pair conversion is considered as weel as the e+ physics for the forward simulation");  
107   fSetEminAdjModelsCmd->SetUnitCategory("Energ <<  96   
108   fSetEminAdjModelsCmd->AvailableForStates(G4S <<  97   SetEminAdjModelsCmd =  new G4UIcmdWithADoubleAndUnit("/adjoint_physics/SetEminForAdjointModels",this);
109                                                <<  98   SetEminAdjModelsCmd->SetGuidance("Set the minimum energy  of the adjoint models");
110   fSetEmaxAdjModelsCmd =                       <<  99   SetEminAdjModelsCmd->SetParameterName("Emin",false);
111     new G4UIcmdWithADoubleAndUnit("/adjoint_ph << 100   SetEminAdjModelsCmd->SetUnitCategory("Energy");
112   fSetEmaxAdjModelsCmd->SetGuidance("Set the m << 101   SetEminAdjModelsCmd->AvailableForStates(G4State_PreInit);
113   fSetEmaxAdjModelsCmd->SetParameterName("Emax << 102   
114   fSetEmaxAdjModelsCmd->SetUnitCategory("Energ << 103   SetEmaxAdjModelsCmd =  new G4UIcmdWithADoubleAndUnit("/adjoint_physics/SetEmaxForAdjointModels",this);
115   fSetEmaxAdjModelsCmd->AvailableForStates(G4S << 104   SetEmaxAdjModelsCmd->SetGuidance("Set the minimum energy  of the adjoint models.");
                                                   >> 105   SetEmaxAdjModelsCmd->SetParameterName("Emax",false);
                                                   >> 106   SetEmaxAdjModelsCmd->SetUnitCategory("Energy");
                                                   >> 107   SetEmaxAdjModelsCmd->AvailableForStates(G4State_PreInit);
                                                   >> 108 /*
                                                   >> 109 #ifdef TEST_MODE   
                                                   >> 110   SetCSBiasingFactorComptonCmd =  new G4UIcmdWithADouble("/adjoint_physics/SetCSBiasingFactorForCompton",this);
                                                   >> 111   SetCSBiasingFactorComptonCmd->SetGuidance("Set the CS biading factor for the adjoint Compton Cross section");
                                                   >> 112   SetCSBiasingFactorComptonCmd->SetParameterName("biasing_factor",false);
                                                   >> 113   SetCSBiasingFactorComptonCmd->AvailableForStates(G4State_PreInit);
                                                   >> 114   
                                                   >> 115   SetCSBiasingFactorBremCmd =  new G4UIcmdWithADouble("/adjoint_physics/SetCSBiasingFactorForBrem",this);
                                                   >> 116   SetCSBiasingFactorBremCmd->SetGuidance("Set the CS biading factor for the adjoint Brem Cross section");
                                                   >> 117   SetCSBiasingFactorBremCmd->SetParameterName("biasing_factor",false);
                                                   >> 118   SetCSBiasingFactorBremCmd->AvailableForStates(G4State_PreInit);
                                                   >> 119   
                                                   >> 120   SetCSBiasingFactorIonisationCmd =  new G4UIcmdWithADouble("/adjoint_physics/SetCSBiasingFactorForIonisation",this);
                                                   >> 121   SetCSBiasingFactorIonisationCmd->SetGuidance("Set the CS biading factor for the adjoint Ionisation Cross section");
                                                   >> 122   SetCSBiasingFactorIonisationCmd->SetParameterName("biasing_factor",false);
                                                   >> 123   SetCSBiasingFactorIonisationCmd->AvailableForStates(G4State_PreInit);
                                                   >> 124   
                                                   >> 125   SetCSBiasingFactorPEeffectCmd =  new G4UIcmdWithADouble("/adjoint_physics/SetCSBiasingFactorForPEeffect",this);
                                                   >> 126   SetCSBiasingFactorPEeffectCmd->SetGuidance("Set the CS biading factor for the adjoint PEeffect Cross section");
                                                   >> 127   SetCSBiasingFactorPEeffectCmd->SetParameterName("biasing_factor",false);
                                                   >> 128   SetCSBiasingFactorPEeffectCmd->AvailableForStates(G4State_PreInit);
                                                   >> 129    
                                                   >> 130  
                                                   >> 131 #endif  
                                                   >> 132 */
                                                   >> 133   
                                                   >> 134  
                                                   >> 135   
                                                   >> 136   
                                                   >> 137     
116 }                                                 138 }
117                                                   139 
118 //....oooOO0OOooo........oooOO0OOooo........oo << 140 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                   >> 141 //
119                                                   142 
120 G4AdjointPhysicsMessenger::~G4AdjointPhysicsMe    143 G4AdjointPhysicsMessenger::~G4AdjointPhysicsMessenger()
121 {                                                 144 {
122   delete fUsepIonisationCmd;                   << 145 
123   delete fUseBremCmd;                          << 146    
124   delete fUseComptonCmd;                       << 147   
125   delete fUseMSCmd;                            << 
126   delete fUsePEEffectCmd;                      << 
127   delete fUseGammaConversionCmd;               << 
128   delete fUseEgainFluctuationCmd;              << 
129   delete fSetEminAdjModelsCmd;                 << 
130   delete fSetEmaxAdjModelsCmd;                 << 
131 }                                                 148 }
132                                                   149 
133 //....oooOO0OOooo........oooOO0OOooo........oo << 150 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                   >> 151 //
134                                                   152 
135 void G4AdjointPhysicsMessenger::SetNewValue(G4 << 153 void G4AdjointPhysicsMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
136 {                                                 154 {
137   if (command == fUsepIonisationCmd) {         << 155   
138     fPhysicsList->SetUseProtonIonisation(fUsep << 156   
                                                   >> 157   
                                                   >> 158   if ( command==UsepIonisationCmd){
                                                   >> 159         thePhysicsList->SetUseProtonIonisation(UsepIonisationCmd->GetNewBoolValue(newValue));
                                                   >> 160      
139   }                                               161   }
140   else if (command == fUseBremCmd) {           << 162   else if ( command==UseBremCmd){
141     fPhysicsList->SetUseBrem(fUseBremCmd->GetN << 163     thePhysicsList->SetUseBrem(UseBremCmd->GetNewBoolValue(newValue));
142   }                                               164   }
143   else if (command == fUseComptonCmd) {        << 165   else if ( command==UseComptonCmd){
144     fPhysicsList->SetUseCompton(fUseComptonCmd << 166   thePhysicsList->SetUseCompton(UseComptonCmd->GetNewBoolValue(newValue));
145   }                                               167   }
146   else if (command == fUseMSCmd) {             << 168   else if ( command==UseMSCmd){
147     fPhysicsList->SetUseMS(fUseMSCmd->GetNewBo << 169     thePhysicsList->SetUseMS(UseMSCmd->GetNewBoolValue(newValue));
148   }                                               170   }
149   else if (command == fUsePEEffectCmd) {       << 171   else if ( command==UsePEEffectCmd){
150     fPhysicsList->SetUsePEEffect(fUsePEEffectC << 172      thePhysicsList->SetUsePEEffect(UsePEEffectCmd->GetNewBoolValue(newValue));
151   }                                               173   }
152   else if (command == fUseGammaConversionCmd)  << 174   else if ( command==UseGammaConversionCmd){
153     fPhysicsList->SetUseGammaConversion(fUseGa << 175      thePhysicsList->SetUseGammaConversion(UseGammaConversionCmd->GetNewBoolValue(newValue));
154   }                                               176   }
155   else if (command == fUseEgainFluctuationCmd) << 177   else if ( command==UseEgainFluctuationCmd){
156     fPhysicsList->SetUseEgainFluctuation(fUseE << 178      thePhysicsList->SetUseEgainFluctuation(UseEgainFluctuationCmd->GetNewBoolValue(newValue));
157   }                                               179   }
158                                                   180 
159   else if (command == fSetEminAdjModelsCmd) {  << 181   else if ( command== SetEminAdjModelsCmd){
160     fPhysicsList->SetEminAdjModels(fSetEminAdj << 182     thePhysicsList->SetEminAdjModels(SetEminAdjModelsCmd->GetNewDoubleValue(newValue));
                                                   >> 183   }
                                                   >> 184   else if ( command== SetEmaxAdjModelsCmd){
                                                   >> 185     thePhysicsList->SetEmaxAdjModels(SetEmaxAdjModelsCmd->GetNewDoubleValue(newValue));
                                                   >> 186   }
                                                   >> 187 /*  
                                                   >> 188 #ifdef TEST_MODE
                                                   >> 189   else if ( command== SetCSBiasingFactorComptonCmd){
                                                   >> 190     thePhysicsList->SetCSBiasingFactorCompton(SetCSBiasingFactorComptonCmd->GetNewDoubleValue(newValue)); 
161   }                                               191   }
162   else if (command == fSetEmaxAdjModelsCmd) {  << 192   else if ( command== SetCSBiasingFactorBremCmd){
163     fPhysicsList->SetEmaxAdjModels(fSetEmaxAdj << 193     thePhysicsList->SetCSBiasingFactorBrem(SetCSBiasingFactorBremCmd->GetNewDoubleValue(newValue)); 
164   }                                               194   }
                                                   >> 195   else if ( command== SetCSBiasingFactorIonisationCmd){
                                                   >> 196     thePhysicsList->SetCSBiasingFactorIonisation(SetCSBiasingFactorIonisationCmd->GetNewDoubleValue(newValue)); 
                                                   >> 197   }
                                                   >> 198   else if ( command== SetCSBiasingFactorPEeffectCmd){
                                                   >> 199     thePhysicsList->SetCSBiasingFactorPEeffect(SetCSBiasingFactorPEeffectCmd->GetNewDoubleValue(newValue)); 
                                                   >> 200   }
                                                   >> 201   
                                                   >> 202  
                                                   >> 203 #endif    
                                                   >> 204 */  
                                                   >> 205 
165 }                                                 206 }
166                                                   207 
167 //....oooOO0OOooo........oooOO0OOooo........oo << 
168                                                   208