Geant4 Cross Reference |
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 // 26 //-------------------------------------------- 27 //--------------------------------------------------------------------------- 27 // 28 // 28 // GEANT4 Class file 29 // GEANT4 Class file 29 // 30 // 30 // Description: Data structure for cross secti 31 // Description: Data structure for cross sections, shell cross sections, 31 // isotope cross sections. Data a << 32 // isotope cross sections. Control of vector size should be 32 // Z (atomic number in majority o << 33 // performed in user code, no protection in this class 33 // be in the interval 0 <= Z < le << 34 // data a second parameter idx or << 35 // In most cases ID = A - atomic << 36 // There are run time const metho << 37 // assuming responsibility of con << 38 // check input and may throwgh a << 39 // 34 // 40 // Author: V.Ivanchenko 10.03.2011 35 // Author: V.Ivanchenko 10.03.2011 41 // 36 // 42 // Modifications: 30.09.2023 Extended function << 37 // Modifications: 43 // 38 // 44 //-------------------------------------------- 39 //---------------------------------------------------------------------------- 45 // 40 // 46 41 47 #ifndef G4ElementData_h << 42 #ifndef ElementData_h 48 #define G4ElementData_h 1 << 43 #define ElementData_h 1 49 44 50 #include "G4Physics2DVector.hh" << 45 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 51 #include "G4PhysicsVector.hh" << 52 #include "globals.hh" << 53 46 >> 47 #include "globals.hh" >> 48 #include "G4NistElementBuilder.hh" >> 49 #include "G4PhysicsVector.hh" >> 50 #include "G4Physics2DVector.hh" 54 #include <vector> 51 #include <vector> 55 52 56 class G4ElementData << 53 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 54 >> 55 class G4ElementData 57 { 56 { 58 public: << 57 public: 59 explicit G4ElementData(G4int length = 99); << 60 58 61 ~G4ElementData(); << 59 explicit G4ElementData(); 62 60 63 // Assignment operator and copy constructor << 61 ~G4ElementData(); 64 G4ElementData& operator=(const G4ElementData << 65 G4ElementData(const G4ElementData&) = delete << 66 62 67 // add cross section for the element 63 // add cross section for the element 68 void InitialiseForElement(G4int Z, G4Physics 64 void InitialiseForElement(G4int Z, G4PhysicsVector* v); 69 65 70 // add 2D cross section for the element 66 // add 2D cross section for the element 71 void InitialiseForElement(G4int Z, G4Physics 67 void InitialiseForElement(G4int Z, G4Physics2DVector* v); 72 68 73 // reserve vector of components 69 // reserve vector of components 74 void InitialiseForComponent(G4int Z, G4int n << 70 void InitialiseForComponent(G4int Z, G4int nComponents=0); 75 << 76 // reserve vector of 2D components << 77 void InitialiseFor2DComponent(G4int Z, G4int << 78 71 79 // prepare vector of components 72 // prepare vector of components 80 void AddComponent(G4int Z, G4int id, G4Physi 73 void AddComponent(G4int Z, G4int id, G4PhysicsVector* v); 81 74 82 // prepare vector of 2D components << 75 // set name of the dataset 83 void Add2DComponent(G4int Z, G4int id, G4Phy << 76 void SetName(const G4String& nam); 84 << 85 // set name of the dataset (optional) << 86 inline void SetName(const G4String& nam); << 87 << 88 //------------------------------------------ << 89 // run time const methods - no check on vali << 90 // it is a responsibility of the consume cod << 91 //------------------------------------------ << 92 << 93 // get name of the dataset << 94 inline const G4String& GetName() const; << 95 << 96 // get vector for the element << 97 inline G4PhysicsVector* GetElementData(G4int << 98 << 99 // get 2-D vector for the element << 100 inline G4Physics2DVector* GetElement2DData(G << 101 << 102 // get vector per shell or per isotope << 103 inline G4PhysicsVector* GetComponentDataByID << 104 << 105 // get vector per shell or per isotope << 106 inline G4Physics2DVector* Get2DComponentData << 107 << 108 // return cross section per element << 109 inline G4double GetValueForElement(G4int Z, << 110 77 111 //------------------------------------------ << 78 // get vector for the element 112 // run time const methods with input paramet << 79 inline G4PhysicsVector* GetElementData(G4int Z); 113 //------------------------------------------ << 114 80 115 // get number of components for the element << 81 // get 2-D vector for the element 116 inline std::size_t GetNumberOfComponents(G4i << 82 inline G4Physics2DVector* GetElement2DData(G4int Z); 117 83 118 // get number of 2D components for the eleme << 84 // get number of components for the element 119 inline std::size_t GetNumberOf2DComponents(G << 85 inline size_t GetNumberOfComponents(G4int Z); 120 86 121 // get component ID which may be number of n << 87 // get component ID which may be number of nucleons, 122 // or shell number, or any other integer 88 // or shell number, or any other integer 123 inline G4int GetComponentID(G4int Z, std::si << 89 inline G4int GetComponentID(G4int Z, size_t idx); 124 90 125 // get vector per shell or per isotope 91 // get vector per shell or per isotope 126 inline G4PhysicsVector* << 92 inline G4PhysicsVector* GetComponentDataByIndex(G4int Z, size_t idx); 127 GetComponentDataByIndex(G4int Z, std::size_t << 128 93 129 // get vector per shell or per isotope 94 // get vector per shell or per isotope 130 inline G4Physics2DVector* << 95 inline G4PhysicsVector* GetComponentDataByID(G4int Z, G4int id); 131 Get2DComponentDataByIndex(G4int Z, std::size << 132 96 133 // return cross section per element << 97 // return cross section per element 134 // if not available return zero 98 // if not available return zero 135 inline G4double << 99 inline G4double GetValueForElement(G4int Z, G4double kinEnergy); 136 GetValueForComponent(G4int Z, std::size_t id << 137 100 138 private: << 101 // return cross section per element 139 << 102 // if not available return zero 140 void DataError(G4int Z, const G4String&); << 103 inline G4double GetValueForComponent(G4int Z, size_t idx, G4double kinEnergy); 141 104 142 const G4int maxNumElm; << 105 private: 143 106 144 std::vector<G4PhysicsVector*> elmData; << 107 // Assignment operator and copy constructor 145 std::vector<G4Physics2DVector*> elm2Data; << 108 G4ElementData & operator=(const G4ElementData &right) = delete; 146 std::vector<std::vector<std::pair<G4int, G4P << 109 G4ElementData(const G4ElementData&) = delete; 147 std::vector<std::vector<std::pair<G4int, G4P << 148 110 149 G4String name{""}; << 111 G4PhysicsVector* elmData[maxNumElements]; >> 112 G4Physics2DVector* elm2Data[maxNumElements]; >> 113 std::vector<G4PhysicsVector*> compData[maxNumElements]; >> 114 std::vector<G4int> compID[maxNumElements]; >> 115 size_t compLength[maxNumElements]; >> 116 G4String name; 150 }; 117 }; 151 118 152 //-------------------------------------------- << 153 // run time const methods without check on val << 154 //-------------------------------------------- << 155 << 156 inline void G4ElementData::SetName(const G4Str 119 inline void G4ElementData::SetName(const G4String& nam) 157 { 120 { 158 name = nam; 121 name = nam; 159 } 122 } 160 123 161 inline const G4String& G4ElementData::GetName( << 124 inline 162 { << 125 G4PhysicsVector* G4ElementData::GetElementData(G4int Z) 163 return name; << 164 } << 165 << 166 inline G4PhysicsVector* G4ElementData::GetElem << 167 { 126 { 168 return elmData[Z]; 127 return elmData[Z]; 169 } 128 } 170 129 171 inline G4Physics2DVector* G4ElementData::GetEl << 130 inline >> 131 G4Physics2DVector* G4ElementData::GetElement2DData(G4int Z) 172 { 132 { 173 return elm2Data[Z]; 133 return elm2Data[Z]; 174 } 134 } 175 135 176 inline G4PhysicsVector* << 136 inline 177 G4ElementData::GetComponentDataByID(G4int Z, G << 137 size_t G4ElementData::GetNumberOfComponents(G4int Z) 178 { << 179 G4PhysicsVector* v = nullptr; << 180 for (auto const & p : *(compData[Z])) { << 181 if (id == p.first) { << 182 v = p.second; << 183 break; << 184 } << 185 } << 186 return v; << 187 } << 188 << 189 inline G4Physics2DVector* << 190 G4ElementData::Get2DComponentDataByID(G4int Z, << 191 { << 192 G4Physics2DVector* v = nullptr; << 193 for (auto const & p : *(comp2D[Z])) { << 194 if (id == p.first) { << 195 v = p.second; << 196 break; << 197 } << 198 } << 199 return v; << 200 } << 201 << 202 inline G4double << 203 G4ElementData::GetValueForElement(G4int Z, G4d << 204 { 138 { 205 return elmData[Z]->Value(kinEnergy); << 139 return compLength[Z]; 206 } 140 } 207 141 208 //-------------------------------------------- << 142 inline G4int G4ElementData::GetComponentID(G4int Z, size_t idx) 209 // run time const methods with check on validi << 210 //-------------------------------------------- << 211 << 212 inline std::size_t G4ElementData::GetNumberOfC << 213 { 143 { 214 return (nullptr != compData[Z]) ? compData[Z << 144 return (compID[Z])[idx]; 215 } 145 } 216 146 217 inline std::size_t G4ElementData::GetNumberOf2 << 147 inline >> 148 G4PhysicsVector* G4ElementData::GetComponentDataByIndex(G4int Z, size_t idx) 218 { 149 { 219 return (nullptr != comp2D[Z]) ? comp2D[Z]->s << 150 return (compData[Z])[idx]; 220 } 151 } 221 152 222 inline G4int G4ElementData::GetComponentID(G4i << 153 inline >> 154 G4PhysicsVector* G4ElementData::GetComponentDataByID(G4int Z, G4int id) 223 { 155 { 224 return (idx < GetNumberOfComponents(Z)) ? (* << 156 G4PhysicsVector* v = 0; >> 157 for(size_t i=0; i<compLength[Z]; ++i) { >> 158 if(id == (compID[Z])[i]) { >> 159 v = (compData[Z])[i]; >> 160 break; >> 161 } >> 162 } >> 163 return v; 225 } 164 } 226 165 227 inline G4PhysicsVector* << 166 inline 228 G4ElementData::GetComponentDataByIndex(G4int Z << 167 G4double G4ElementData::GetValueForElement(G4int Z, G4double kinEnergy) 229 { 168 { 230 return << 169 return elmData[Z]->Value(kinEnergy); 231 (idx < GetNumberOfComponents(Z)) ? (*(comp << 232 } 170 } 233 171 234 inline G4Physics2DVector* << 172 inline G4double 235 G4ElementData::Get2DComponentDataByIndex(G4int << 173 G4ElementData::GetValueForComponent(G4int Z, size_t idx, G4double kinEnergy) 236 { 174 { 237 return << 175 return ((compData[Z])[idx])->Value(kinEnergy); 238 (idx < GetNumberOf2DComponents(Z)) ? (*(co << 239 } 176 } 240 177 241 inline G4double << 178 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 242 G4ElementData::GetValueForComponent(G4int Z, s << 243 { << 244 return (idx < GetNumberOfComponents(Z)) ? << 245 (*(compData[Z]))[idx].second->Value(e) : 0 << 246 } << 247 179 248 #endif 180 #endif >> 181 249 182