#include <G4InterpolationManager.hh>
Public Member Functions | |
G4InterpolationManager () | |
~G4InterpolationManager () | |
G4InterpolationManager & | operator= (const G4InterpolationManager &aManager) |
void | Init (G4int aScheme, G4int aRange) |
void | Init (G4InterpolationScheme aScheme, G4int aRange) |
void | Init (std::ifstream &aDataFile) |
G4InterpolationScheme | MakeScheme (G4int it) |
G4InterpolationScheme | GetScheme (G4int index) const |
void | CleanUp () |
G4InterpolationScheme | GetInverseScheme (G4int index) |
void | AppendScheme (G4int aPoint, const G4InterpolationScheme &aScheme) |
Friends | |
class | G4InterpolationIterator |
Definition at line 38 of file G4InterpolationManager.hh.
G4InterpolationManager::G4InterpolationManager | ( | ) | [inline] |
Definition at line 44 of file G4InterpolationManager.hh.
References LINLIN.
00045 { 00046 nRanges = 1; 00047 start = new G4int[1]; 00048 start[0] = 0; 00049 range = new G4int[1]; 00050 range [0] = 100000; 00051 scheme = new G4InterpolationScheme[1]; 00052 scheme[0] = LINLIN; 00053 nEntries = 0; 00054 }
G4InterpolationManager::~G4InterpolationManager | ( | ) | [inline] |
Definition at line 56 of file G4InterpolationManager.hh.
00057 { 00058 if(start!=0) delete [] start; 00059 if(range!=0) delete [] range; 00060 if(scheme!=0) delete [] scheme; 00061 }
void G4InterpolationManager::AppendScheme | ( | G4int | aPoint, | |
const G4InterpolationScheme & | aScheme | |||
) |
Definition at line 90 of file G4InterpolationManager.cc.
References buffer, G4cout, and G4endl.
Referenced by G4NeutronHPVector::Merge(), and G4NeutronHPVector::SetScheme().
00091 { 00092 if(aPoint!=nEntries) 00093 { 00094 G4cout <<"G4InterpolationManager::AppendScheme - "<<aPoint<<" "<<nEntries<<G4endl; 00095 throw G4HadronicException(__FILE__, __LINE__, "Wrong usage of G4InterpolationManager::AppendScheme"); 00096 } 00097 if(nEntries==0) 00098 { 00099 nEntries = 1; 00100 nRanges = 1; 00101 start[0] = 0; 00102 range [0] = 1; 00103 scheme[0] = aScheme; 00104 } 00105 else if(aScheme==scheme[nRanges-1]) 00106 { 00107 ++range[nRanges-1]; 00108 nEntries++; 00109 } 00110 else 00111 { 00112 nEntries++; 00113 nRanges++; 00114 G4int i; 00115 G4int * buffer = new G4int[nRanges]; 00116 G4int * buffer1 = new G4int[nRanges]; 00117 G4InterpolationScheme* buff2 = new G4InterpolationScheme[nRanges]; 00118 for(i=0; i<nRanges-1; i++) 00119 { 00120 buffer[i] = start[i]; 00121 buffer1[i] = range[i]; 00122 buff2[i] = scheme[i]; 00123 } 00124 delete [] start; 00125 delete [] range; 00126 delete [] scheme; 00127 start = buffer; 00128 range = buffer1; 00129 scheme = buff2; 00130 start[nRanges-1] = start[nRanges-2]+range[nRanges-2]; 00131 range[nRanges-1] = 1; 00132 scheme[nRanges-1] = aScheme; 00133 } 00134 }
void G4InterpolationManager::CleanUp | ( | ) | [inline] |
Definition at line 143 of file G4InterpolationManager.hh.
Referenced by G4NeutronHPVector::CleanUp().
G4InterpolationScheme G4InterpolationManager::GetInverseScheme | ( | G4int | index | ) | [inline] |
Definition at line 149 of file G4InterpolationManager.hh.
References CHISTO, CLINLOG, CLOGLIN, CRANDOM, GetScheme(), HISTO, LINLOG, LOGLIN, RANDOM, UHISTO, ULINLOG, ULOGLIN, and URANDOM.
Referenced by G4NeutronHPContAngularPar::Sample().
00150 { 00151 G4InterpolationScheme result = GetScheme(index); 00152 if(result == HISTO) 00153 { 00154 result = RANDOM; 00155 } 00156 else if(result == LINLOG) 00157 { 00158 result = LOGLIN; 00159 } 00160 else if(result == LOGLIN) 00161 { 00162 result = LINLOG; 00163 } 00164 else if(result == CHISTO) 00165 { 00166 result = CRANDOM; 00167 } 00168 else if(result == CLINLOG) 00169 { 00170 result = CLOGLIN; 00171 } 00172 else if(result == CLOGLIN) 00173 { 00174 result = CLINLOG; 00175 } 00176 else if(result == UHISTO) 00177 { 00178 result = URANDOM; 00179 } 00180 else if(result == ULINLOG) 00181 { 00182 result = ULOGLIN; 00183 } 00184 else if(result == ULOGLIN) 00185 { 00186 result = ULINLOG; 00187 } 00188 return result; 00189 }
G4InterpolationScheme G4InterpolationManager::GetScheme | ( | G4int | index | ) | const [inline] |
Definition at line 132 of file G4InterpolationManager.hh.
Referenced by G4NeutronHPAngularP::GetCosTh(), GetInverseScheme(), G4NeutronHPVector::GetMeanX(), G4NeutronHPVector::GetScheme(), G4NeutronHPVector::GetXsec(), G4NeutronHPPartial::GetY(), G4NeutronHPVector::Integrate(), G4NeutronHPVector::IntegrateAndNormalise(), G4NeutronHPPartial::Sample(), G4NeutronHPLegendreStore::Sample(), G4NeutronHPLabAngularEnergy::Sample(), G4NeutronHPDiscreteTwoBody::Sample(), G4NeutronHPContAngularPar::Sample(), G4NeutronHPLegendreStore::SampleDiscreteTwoBody(), G4NeutronHPLegendreStore::SampleElastic(), and G4NeutronHPLegendreStore::SampleMax().
00133 { 00134 G4int it = 0; 00135 for(G4int i=1; i<nRanges; i++) 00136 { 00137 if(index<start[i]) break; 00138 it = i; 00139 } 00140 return scheme[it]; 00141 }
void G4InterpolationManager::Init | ( | std::ifstream & | aDataFile | ) | [inline] |
Definition at line 102 of file G4InterpolationManager.hh.
References MakeScheme().
00103 { 00104 delete [] start; 00105 delete [] range; 00106 delete [] scheme; 00107 aDataFile >> nRanges; 00108 start = new G4int[nRanges]; 00109 range = new G4int[nRanges]; 00110 scheme = new G4InterpolationScheme[nRanges]; 00111 start[0] = 0; 00112 G4int it; 00113 for(G4int i=0; i<nRanges; i++) 00114 { 00115 aDataFile>>range[i]; 00116 //*************************************************************** 00117 //EMendoza -> there is a bug here. 00118 /* 00119 if(i!=0) start[i] = start[i-1]+range[i-1]; 00120 */ 00121 //*************************************************************** 00122 if(i!=0) start[i] = range[i-1]; 00123 //*************************************************************** 00124 aDataFile>>it; 00125 scheme[i] = MakeScheme(it); 00126 } 00127 nEntries = start[nRanges-1]+range[nRanges-1]; 00128 }
void G4InterpolationManager::Init | ( | G4InterpolationScheme | aScheme, | |
G4int | aRange | |||
) | [inline] |
Definition at line 93 of file G4InterpolationManager.hh.
00094 { 00095 nRanges = 1; 00096 start[0] = 0; 00097 range [0] = aRange; 00098 scheme[0] = aScheme; 00099 nEntries = aRange; 00100 }
Definition at line 85 of file G4InterpolationManager.hh.
References MakeScheme().
Referenced by G4NeutronHPVector::Init(), G4NeutronHPLabAngularEnergy::Init(), G4NeutronHPDiscreteTwoBody::Init(), G4NeutronHPContEnergyAngular::Init(), G4NeutronHPArbitaryTab::Init(), G4NeutronHPAngularP::Init(), G4NeutronHPPhotonDist::InitAngular(), G4NeutronHPVector::InitInterpolation(), G4NeutronHPPartial::InitInterpolation(), G4NeutronHPLegendreStore::InitInterpolation(), G4NeutronHPDiscreteTwoBody::Sample(), G4NeutronHPContAngularPar::Sample(), and G4NeutronHPContAngularPar::SetInterpolation().
00086 { 00087 nRanges = 1; 00088 start[0] = 0; 00089 range [0] = aRange; 00090 scheme[0] = MakeScheme(aScheme); 00091 nEntries = aRange; 00092 }
G4InterpolationScheme G4InterpolationManager::MakeScheme | ( | G4int | it | ) |
Definition at line 33 of file G4InterpolationManager.cc.
References CHISTO, CLINLIN, CLINLOG, CLOGLIN, CLOGLOG, HISTO, LINLIN, LINLOG, LOGLIN, LOGLOG, UHISTO, ULINLIN, ULINLOG, ULOGLIN, and ULOGLOG.
Referenced by Init().
00034 { 00035 G4InterpolationScheme result(LINLIN); 00036 switch(it) 00037 { 00038 case 1: 00039 result = HISTO; 00040 break; 00041 case 2: 00042 result = LINLIN; 00043 break; 00044 case 3: 00045 result = LINLOG; 00046 break; 00047 case 4: 00048 result = LOGLIN; 00049 break; 00050 case 5: 00051 result = LOGLOG; 00052 break; 00053 case 11: 00054 result = CHISTO; 00055 break; 00056 case 12: 00057 result = CLINLIN; 00058 break; 00059 case 13: 00060 result = CLINLOG; 00061 break; 00062 case 14: 00063 result = CLOGLIN; 00064 break; 00065 case 15: 00066 result = CLOGLOG; 00067 break; 00068 case 21: 00069 result = UHISTO; 00070 break; 00071 case 22: 00072 result = ULINLIN; 00073 break; 00074 case 23: 00075 result = ULINLOG; 00076 break; 00077 case 24: 00078 result = ULOGLIN; 00079 break; 00080 case 25: 00081 result = ULOGLOG; 00082 break; 00083 default: 00084 throw G4HadronicException(__FILE__, __LINE__, "G4InterpolationManager: unknown interpolation scheme"); 00085 break; 00086 } 00087 return result; 00088 }
G4InterpolationManager& G4InterpolationManager::operator= | ( | const G4InterpolationManager & | aManager | ) | [inline] |
Definition at line 63 of file G4InterpolationManager.hh.
References nEntries, nRanges, range, scheme, and start.
00064 { 00065 if(this != &aManager) 00066 { 00067 nRanges = aManager.nRanges; 00068 nEntries = aManager.nEntries; 00069 if(scheme!=0) delete [] scheme; 00070 if(start!=0) delete [] start; 00071 if(range!=0) delete [] range; 00072 scheme = new G4InterpolationScheme[nRanges]; 00073 start = new G4int[nRanges]; 00074 range = new G4int[nRanges]; 00075 for(G4int i=0; i<nRanges; i++) 00076 { 00077 scheme[i]=aManager.scheme[i]; 00078 start[i]=aManager.start[i]; 00079 range[i]=aManager.range[i]; 00080 } 00081 } 00082 return *this; 00083 }
friend class G4InterpolationIterator [friend] |
Definition at line 42 of file G4InterpolationManager.hh.