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