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 // P. Arce, June-2014 Conversion neutron_hp to 27 // P. Arce, June-2014 Conversion neutron_hp to particle_hp 28 // 28 // 29 #ifndef G4ParticleHPParticleYield_h 29 #ifndef G4ParticleHPParticleYield_h 30 #define G4ParticleHPParticleYield_h 1 30 #define G4ParticleHPParticleYield_h 1 31 31 32 #include "G4ParticleHPList.hh" << 33 #include "G4ParticleHPPolynomExpansion.hh" << 34 #include "G4ParticleHPVector.hh" << 35 #include "globals.hh" << 36 << 37 #include <CLHEP/Units/SystemOfUnits.h> 32 #include <CLHEP/Units/SystemOfUnits.h> 38 33 >> 34 #include "globals.hh" >> 35 #include "G4ParticleHPVector.hh" >> 36 #include "G4ParticleHPPolynomExpansion.hh" >> 37 #include "G4ParticleHPList.hh" >> 38 39 class G4ParticleHPParticleYield 39 class G4ParticleHPParticleYield 40 { 40 { 41 public: 41 public: 42 << 42 G4ParticleHPParticleYield() 43 G4ParticleHPParticleYield() << 43 { 44 { << 44 simpleMean = true; 45 simpleMean = true; << 45 spontPrompt = true; 46 spontPrompt = true; << 46 hasPromptData = false; 47 hasPromptData = false; << 47 hasDelayedData = false; 48 hasDelayedData = false; << 48 49 << 49 targetMass = 0.0; 50 targetMass = 0.0; << 50 theSpontPrompt = 0.0; 51 theSpontPrompt = 0.0; << 51 spontDelayed = true; 52 spontDelayed = true; << 52 theSpontDelayed = 0.0; 53 theSpontDelayed = 0.0; << 53 } 54 } << 54 ~G4ParticleHPParticleYield(){} 55 << 55 56 ~G4ParticleHPParticleYield() = default; << 56 G4double GetTargetMass() { return targetMass; } 57 << 57 58 inline G4double GetTargetMass() const { re << 58 void InitMean(std::istream & aDataFile) 59 << 59 { 60 inline void InitMean(std::istream& aDataFi << 60 G4int iflag; 61 { << 61 aDataFile >> targetMass >>iflag; 62 G4int iflag; << 62 if(iflag == 1) simpleMean=false; 63 aDataFile >> targetMass >> iflag; << 63 if(simpleMean) 64 if (iflag == 1) simpleMean = false; << 64 { 65 if (simpleMean) { << 65 theSimpleMean.Init(aDataFile, CLHEP::eV); 66 theSimpleMean.Init(aDataFile, CLHEP::e << 66 } 67 } << 67 else 68 else { << 68 { 69 theMean.Init(aDataFile); << 69 theMean.Init(aDataFile); 70 } << 70 } 71 } << 71 } 72 << 72 73 inline void InitPrompt(std::istream& aData << 73 void InitPrompt(std::istream & aDataFile) 74 { << 74 { 75 hasPromptData = true; << 75 hasPromptData = true; 76 G4int iflag; << 76 G4int iflag; 77 aDataFile >> targetMass >> iflag; << 77 aDataFile >> targetMass >>iflag; 78 if (iflag == 2) spontPrompt = false; << 78 if(iflag == 2) spontPrompt = false; 79 if (spontPrompt) { << 79 if(spontPrompt) 80 aDataFile >> theSpontPrompt; << 80 { 81 } << 81 aDataFile >> theSpontPrompt; 82 else { << 82 } 83 thePrompt.Init(aDataFile, CLHEP::eV); << 83 else 84 } << 84 { 85 } << 85 thePrompt.Init(aDataFile, CLHEP::eV); 86 << 86 } 87 inline void InitDelayed(std::istream& aDat << 87 } 88 { << 88 89 hasDelayedData = true; << 89 void InitDelayed(std::istream & aDataFile) 90 G4int iflag; << 90 { 91 aDataFile >> targetMass >> iflag; << 91 hasDelayedData = true; 92 thePrecursorDecayConstants.Init(aDataFil << 92 G4int iflag; 93 if (iflag == 2) spontDelayed = false; << 93 aDataFile >> targetMass >>iflag; 94 if (spontDelayed) { << 94 thePrecursorDecayConstants.Init(aDataFile, 1./CLHEP::s); // s is the CLHEP unit second 95 aDataFile >> theSpontDelayed; << 95 if(iflag == 2) spontDelayed = false; 96 } << 96 if(spontDelayed) 97 else { << 97 { 98 theDelayed.Init(aDataFile, CLHEP::eV); << 98 aDataFile >> theSpontDelayed; 99 } << 99 } 100 } << 100 else 101 << 101 { 102 inline G4double GetMean(G4double anEnergy) << 102 theDelayed.Init(aDataFile, CLHEP::eV); 103 { << 103 } 104 if (simpleMean) { << 104 } 105 return theSimpleMean.GetY(anEnergy); << 105 106 } << 106 G4double GetMean(G4double anEnergy) 107 return theMean.GetValue(anEnergy); << 107 { 108 } << 108 if(simpleMean) 109 << 109 { 110 inline G4double GetPrompt(G4double anEnerg << 110 return theSimpleMean.GetY(anEnergy); 111 { << 111 } 112 if (!hasPromptData) return 0; << 112 return theMean.GetValue(anEnergy); 113 if (spontPrompt) { << 113 } 114 return theSpontPrompt; << 114 115 } << 115 G4double GetPrompt(G4double anEnergy) 116 return thePrompt.GetY(anEnergy); << 116 { 117 } << 117 if(!hasPromptData) return 0; 118 << 118 if(spontPrompt) 119 inline G4double GetDelayed(G4double anEner << 119 { 120 { << 120 return theSpontPrompt; 121 if (!hasDelayedData) return 0; << 121 } 122 if (spontDelayed) { << 122 return thePrompt.GetY(anEnergy); 123 return theSpontDelayed; << 123 } 124 } << 124 125 return theDelayed.GetY(anEnergy); << 125 G4double GetDelayed(G4double anEnergy) 126 } << 126 { 127 << 127 if(!hasDelayedData) return 0; 128 inline G4double GetDecayConstant(G4int i) << 128 if(spontDelayed) 129 { << 129 { 130 return thePrecursorDecayConstants.GetVal << 130 return theSpontDelayed; 131 } << 131 } 132 << 132 return theDelayed.GetY(anEnergy); >> 133 } >> 134 >> 135 inline G4double GetDecayConstant(G4int i) >> 136 { >> 137 return thePrecursorDecayConstants.GetValue(i); >> 138 } >> 139 133 private: 140 private: >> 141 >> 142 G4double targetMass; >> 143 // total mean >> 144 G4bool simpleMean; >> 145 G4ParticleHPPolynomExpansion theMean; >> 146 G4ParticleHPVector theSimpleMean; >> 147 >> 148 // Prompt neutrons >> 149 G4bool hasPromptData; >> 150 G4bool spontPrompt; >> 151 G4ParticleHPVector thePrompt; >> 152 G4double theSpontPrompt; >> 153 >> 154 // delayed neutrons >> 155 G4bool hasDelayedData; >> 156 G4bool spontDelayed; >> 157 G4ParticleHPList thePrecursorDecayConstants; >> 158 G4ParticleHPVector theDelayed; >> 159 G4double theSpontDelayed; 134 160 135 G4double targetMass; << 136 // total mean << 137 G4bool simpleMean; << 138 G4ParticleHPPolynomExpansion theMean; << 139 G4ParticleHPVector theSimpleMean; << 140 << 141 // Prompt neutrons << 142 G4bool hasPromptData; << 143 G4bool spontPrompt; << 144 G4ParticleHPVector thePrompt; << 145 G4double theSpontPrompt; << 146 << 147 // delayed neutrons << 148 G4bool hasDelayedData; << 149 G4bool spontDelayed; << 150 G4ParticleHPList thePrecursorDecayConstant << 151 G4ParticleHPVector theDelayed; << 152 G4double theSpontDelayed; << 153 }; 161 }; 154 << 155 #endif 162 #endif 156 163