00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include "G4LevelReader.hh"
00043 #include "G4NucLevel.hh"
00044 #include "G4SystemOfUnits.hh"
00045
00046 G4LevelReader::G4LevelReader()
00047 : nLevels(0),nLevelMax(50),fVerbose(0),fMinProbability(1.e-10)
00048 {
00049 fLevelEnergy = fNewEnergy = fDeltaEnergy = fNewTime
00050 = fHalfLifeTime = fProbability = fICC = fx = 0.0;
00051 eGamma.resize(nLevelMax,0.0);
00052 wGamma.resize(nLevelMax,0.0);
00053 kICC.resize(nLevelMax,0.0);
00054 for(G4int i=0; i<30; ++i) { buffer[i] = 0; }
00055 }
00056
00057 G4LevelReader::~G4LevelReader()
00058 {}
00059
00060 void G4LevelReader::FillLevels(G4int Z, G4int A,
00061 std::vector<G4NucLevel*>* levels,
00062 const G4String& filename)
00063 {
00064 std::ifstream inFile(filename);
00065 if (!inFile.is_open()) {
00066 if (fVerbose > 0) {
00067 G4cout << " G4LevelReader: nuclide ("
00068 << Z << "," << A
00069 << ") does not have a gamma levels file" << G4endl;
00070 }
00071 return;
00072 }
00073
00074
00075 fLevelEnergy = 0.0;
00076 nLevels = 0;
00077
00078
00079 while(Read(inFile)) {
00080
00081
00082 if(fNewEnergy != fLevelEnergy) {
00083 if(0 < nLevels) { MakeNewLevel(levels); }
00084 fLevelEnergy = fNewEnergy;
00085 fHalfLifeTime = fNewTime;
00086 nLevels = 0;
00087 }
00088
00089
00090 eGamma[nLevels] = fDeltaEnergy*keV;
00091 wGamma[nLevels] = std::max(fProbability*0.01,fMinProbability);
00092 kICC[nLevels] = fICC;
00093 ++nLevels;
00094
00095
00096 if(nLevels > nLevelMax) {
00097 nLevelMax += 10;
00098 eGamma.resize(nLevelMax);
00099 wGamma.resize(nLevelMax);
00100 kICC.resize(nLevelMax);
00101 }
00102 }
00103
00104 if(0 < nLevels) {
00105 MakeNewLevel(levels);
00106 inFile.close();
00107 }
00108 }
00109
00110 G4bool G4LevelReader::Read(std::ifstream& dataFile)
00111 {
00112
00113 return (ReadDataItem(dataFile, fNewEnergy) &&
00114 ReadDataItem(dataFile, fDeltaEnergy) &&
00115 ReadDataItem(dataFile, fProbability) &&
00116 ReadDataItem(dataFile, fx) &&
00117 ReadDataItem(dataFile, fNewTime) &&
00118 ReadDataItem(dataFile, fx) &&
00119 ReadDataItem(dataFile, fICC) &&
00120 ReadDataItem(dataFile, fx) &&
00121 ReadDataItem(dataFile, fx) &&
00122 ReadDataItem(dataFile, fx) &&
00123 ReadDataItem(dataFile, fx) &&
00124 ReadDataItem(dataFile, fx) &&
00125 ReadDataItem(dataFile, fx) &&
00126 ReadDataItem(dataFile, fx) &&
00127 ReadDataItem(dataFile, fx) &&
00128 ReadDataItem(dataFile, fx) &&
00129 ReadDataItem(dataFile, fx) );
00130 }
00131
00132 G4bool
00133 G4LevelReader::ReadDataItem(std::istream& dataFile, G4double& x)
00134 {
00135 G4bool okay = (dataFile >> buffer);
00136 if (okay) x = strtod(buffer, NULL);
00137
00138 return okay;
00139 }
00140
00141 void G4LevelReader::MakeNewLevel(std::vector<G4NucLevel*>* levels)
00142 {
00143
00144 G4double norm = 0.0;
00145 for(size_t i=0; i<nLevels; ++i) { norm += wGamma[i]; }
00146
00147
00148 if(norm <= 0.0) { return; }
00149
00150 norm = 1.0/norm;
00151 for(size_t i=0; i<nLevels; ++i) { wGamma[i] *= norm; }
00152
00153
00154 norm = 0.0;
00155 for(size_t i=0; i<nLevels; ++i) {
00156 wGamma[i] /= (1.0 + kICC[i]);
00157 norm += wGamma[i];
00158 }
00159 norm = 1.0/norm;
00160 fHalfLifeTime *= norm*second;
00161
00162
00163 if(1 == nLevels) {
00164 wGamma[0] = 1.0;
00165 } else if(2 == nLevels) {
00166 wGamma[0] *= norm;
00167 wGamma[1] = 1.0;
00168 } else {
00169 wGamma[0] *= norm;
00170 for(size_t i=1; i<nLevels-1; ++i) {
00171 wGamma[i] = wGamma[i]*norm + wGamma[i-1];
00172 }
00173 wGamma[nLevels-1] = 1.0;
00174 }
00175 G4NucLevel* p = new G4NucLevel(fLevelEnergy, fHalfLifeTime,
00176 eGamma, wGamma);
00177 levels->push_back(p);
00178 return;
00179 }
00180