Geant4 Cross Reference |
1 // 1 2 // ******************************************* 3 // * License and Disclaimer 4 // * 5 // * The Geant4 software is copyright of th 6 // * the Geant4 Collaboration. It is provided 7 // * conditions of the Geant4 Software License 8 // * LICENSE and available at http://cern.ch/ 9 // * include a list of copyright holders. 10 // * 11 // * Neither the authors of this software syst 12 // * institutes,nor the agencies providing fin 13 // * work make any representation or warran 14 // * regarding this software system or assum 15 // * use. Please see the license in the file 16 // * for the full disclaimer and the limitatio 17 // * 18 // * This code implementation is the result 19 // * technical work of the GEANT4 collaboratio 20 // * By using, copying, modifying or distri 21 // * any work based on the software) you ag 22 // * use in resulting scientific publicati 23 // * acceptance of all terms of the Geant4 Sof 24 // ******************************************* 25 // 26 // 27 // Hadronic Interaction base class 28 // original by H.P. Wellisch 29 // modified by J.L. Chuma, TRIUMF, 21-Mar-1997 30 // Last modified: 04-Apr-1997 31 // reimplemented 1.11.2003 JPW. 32 // 23-Jan-2009 V.Ivanchenko move constructor a 33 34 #include <iostream> 35 36 #include "G4HadronicInteraction.hh" 37 #include "G4SystemOfUnits.hh" 38 #include "G4HadronicInteractionRegistry.hh" 39 #include "G4HadronicParameters.hh" 40 41 G4HadronicInteraction::G4HadronicInteraction(c 42 verboseLevel(0), theMinEnergy(0.0), 43 isBlocked(false), recoilEnergyThreshold(0.0) 44 epCheckLevels(DBL_MAX, DBL_MAX) 45 { 46 theMaxEnergy = G4HadronicParameters::Instanc 47 registry = G4HadronicInteractionRegistry::In 48 registry->RegisterMe(this); 49 } 50 51 G4HadronicInteraction::~G4HadronicInteraction( 52 { 53 registry->RemoveMe(this); 54 } 55 56 void G4HadronicInteraction::BuildPhysicsTable( 57 {} 58 59 void G4HadronicInteraction::InitialiseModel() 60 {} 61 62 G4HadFinalState* 63 G4HadronicInteraction::ApplyYourself(const G4H 64 { 65 return nullptr; 66 } 67 68 G4double 69 G4HadronicInteraction::SampleInvariantT(const 70 G4double, G4int, G4int) 71 { 72 return 0.0; 73 } 74 75 G4bool G4HadronicInteraction::IsApplicable(con 76 G4Nucleus&) 77 { 78 return true; 79 } 80 81 G4double G4HadronicInteraction::GetMinEnergy( 82 const G4Material *aMaterial, const G4Elemen 83 { 84 if(!IsBlocked()) { return theMinEnergy; } 85 if( IsBlocked(aMaterial) || IsBlocked(anElem 86 if(!theMinEnergyListElements.empty()) { 87 for(auto const& elmlist : theMinEnergyList 88 if( anElement == elmlist.second ) 89 { return elmlist.first; } 90 } 91 } 92 if(!theMinEnergyList.empty()) { 93 for(auto const & matlist : theMinEnergyLis 94 if( aMaterial == matlist.second ) 95 { return matlist.first; } 96 } 97 } 98 return theMinEnergy; 99 } 100 101 void G4HadronicInteraction::SetMinEnergy(G4dou 102 const G4Element *anElement ) 103 { 104 Block(); 105 if(!theMinEnergyListElements.empty()) { 106 for(auto & elmlist : theMinEnergyListEleme 107 if( anElement == elmlist.second ) { 108 elmlist.first = anEnergy; 109 return; 110 } 111 } 112 } 113 theMinEnergyListElements.push_back(std::pair 114 } 115 116 void G4HadronicInteraction::SetMinEnergy(G4dou 117 const G4Material *aMaterial ) 118 { 119 Block(); 120 if(!theMinEnergyList.empty()) { 121 for(auto & matlist : theMinEnergyList) { 122 if( aMaterial == matlist.second ) { 123 matlist.first = anEnergy; 124 return; 125 } 126 } 127 } 128 theMinEnergyList.push_back(std::pair<G4doubl 129 } 130 131 G4double G4HadronicInteraction::GetMaxEnergy(c 132 const G4Element *anElement ) co 133 { 134 if(!IsBlocked()) { return theMaxEnergy; } 135 if( IsBlocked(aMaterial) || IsBlocked(anElem 136 if(!theMaxEnergyListElements.empty()) { 137 for(auto const& elmlist : theMaxEnergyList 138 if( anElement == elmlist.second ) 139 { return elmlist.first; } 140 } 141 } 142 if(!theMaxEnergyList.empty()) { 143 for(auto const& matlist : theMaxEnergyList 144 if( aMaterial == matlist.second ) 145 { return matlist.first; } 146 } 147 } 148 return theMaxEnergy; 149 } 150 151 void G4HadronicInteraction::SetMaxEnergy(G4dou 152 const G4Element *anElement ) 153 { 154 Block(); 155 if(!theMaxEnergyListElements.empty()) { 156 for(auto & elmlist : theMaxEnergyListEleme 157 if( anElement == elmlist.second ) { 158 elmlist.first = anEnergy; 159 return; 160 } 161 } 162 } 163 theMaxEnergyListElements.push_back(std::pair 164 } 165 166 void G4HadronicInteraction::SetMaxEnergy(G4dou 167 { 168 Block(); 169 if(!theMaxEnergyList.empty()) { 170 for(auto & matlist: theMaxEnergyList) { 171 if( aMaterial == matlist.second ) { 172 matlist.first = anEnergy; 173 return; 174 } 175 } 176 } 177 theMaxEnergyList.push_back(std::pair<G4doubl 178 } 179 180 void G4HadronicInteraction::DeActivateFor( con 181 { 182 Block(); 183 theBlockedList.push_back(aMaterial); 184 } 185 186 void G4HadronicInteraction::DeActivateFor( con 187 { 188 Block(); 189 theBlockedListElements.push_back(anElement); 190 } 191 192 193 G4bool G4HadronicInteraction::IsBlocked(const 194 { 195 for (auto const& mat : theBlockedList) { 196 if (aMaterial == mat) return true; 197 } 198 return false; 199 } 200 201 202 G4bool G4HadronicInteraction::IsBlocked(const 203 { 204 for (auto const& elm : theBlockedListElement 205 if (anElement == elm) return true; 206 } 207 return false; 208 } 209 210 const std::pair<G4double, G4double> G4Hadronic 211 { 212 // default level of Check 213 return std::pair<G4double, G4double>(2.*perC 214 } 215 216 std::pair<G4double, G4double> 217 G4HadronicInteraction::GetEnergyMomentumCheckL 218 { 219 return epCheckLevels; 220 } 221 222 void G4HadronicInteraction::ModelDescription(s 223 { 224 outFile << "The description for this model h 225 } 226 227