def masterRayl(numDeps, numLams, temp, lambdaScale, stagePops, gsName,
gsFirstMol, molPops):
""" /*c******************************************************************************
c The subroutines needed to calculate the opacities from scattering by
c H I, H2, He I, are in this file. These are from ATLAS9.
c******************************************************************************
*/"""
#//System.out.println("masterRayl called...");
#//From Moog source file Opacitymetals.f
#// From how values such as aC1[] are used in Moog file Opacit.f to compute the total opacity
#// and then the optical depth scale, I infer that they are extinction coefficients
#// in cm^-1
#//
#// There does not seem to be any correction for stimulated emission
logE = math.log10(math.e)
masterRScat = [[0.0 for i in range(numDeps)] for j in range(numLams)]
logUH1 = [0.0 for i in range(5)]
logUHe1 = [0.0 for i in range(5)]
logStatWH1 = 0.0
logStatWHe1 = 0.0
theta = 1.0
species = ""
logGroundPopsH1 = [0.0 for i in range(numDeps)]
logGroundPopsHe1 = [0.0 for i in range(numDeps)]
logH2Pops = [0.0 for i in range(numDeps)]
#//
#// H I: Z=1 --> iZ=0:
sigH1 = [0.0 for i in range(numDeps)]
#// He I: Z=2 --> iZ=1:
sigHe1 = [0.0 for i in range(numDeps)]
species = "HI"
logUH1 = PartitionFn.getPartFn2(species)
species = "HeI"
logUHe1 = PartitionFn.getPartFn2(species)
sigH2 = [0.0 for i in range(numDeps)]
#Find index of H2 in molPops array
for iH2 in range(len(gsName)):
if (gsName[iH2].strip() == "H2"):
break
#print("iH2 ", iH2, " iH2-gsFirstMol ", (iH2-gsFirstMol))
#//System.out.println("iD PopsH1 PopsHe1");
for iD in range(numDeps):
#//neutral stage
#//Assumes ground state stat weight, g_1, is 1.0
#theta = 5040.0 / temp[0][iD]
#// U[0]: theta = 1.0, U[1]: theta = 0.5
"""
if (theta <= 0.5):
logStatWH1 = logUH1[1]
logStatWHe1 = logUHe1[1]
elif ( (theta < 1.0) and (theta > 0.5) ):
logStatWH1 = ( (theta-0.5) * logUH1[0] ) + ( (1.0-theta) * logUH1[1] )
logStatWHe1 = ( (theta-0.5) * logUHe1[0] ) + ( (1.0-theta) * logUHe1[1] )
#//divide by common factor of interpolation interval of 0.5 = (1.0 - 0.5):
logStatWH1 = 2.0 * logStatWH1
logStatWHe1 = 2.0 * logStatWHe1
else:
logStatWH1 = logUH1[0]
logStatWHe1 = logUHe1[0]
"""
thisTemp = temp[0][iD]
#JB#
logWH1Fit = ToolBox.cubicFit(masterTemp, logUH1)
logStatWH1 = ToolBox.valueFromFit(logWH1Fit, thisTemp)
logWHe1Fit = ToolBox.cubicFit(masterTemp, logUHe1)
logStatWHe1 = ToolBox.valueFromFit(logWHe1Fit, thisTemp)
#logStatWH1Fun = spline(masterTemp,logUH1)
#logStatWH1=logStatWH1Fun(thisTemp)
#logStatWHe1Fun = spline(masterTemp,logUHe1)
#logStatWHe1=logStatWHe1Fun(thisTemp)
#JB#
#// NEW Interpolation with temperature for new partition function: lburns
thisTemp = temp[0][iD]
if (thisTemp <= 130.0):
logStatWH1 = logUH1[0]
logStatWHe1 = logUHe1[0]
if (thisTemp >= 10000.0):
logStatWH1 = logUH1[4]
logStatWHe1 = logUHe1[4]
"""
elif (thisTemp > 130 and thisTemp <= 500):
logStatWH1 = logUH1[1] * (thisTemp - 130)/(500 - 130) \
+ logUH1[0] * (500 - thisTemp)/(500 - 130)
logStatWHe1 = logUHe1[1] * (thisTemp - 130)/(500 - 130) \
+ logUHe1[0] * (500 - thisTemp)/(500 - 130)
elif (thisTemp > 500 and thisTemp <= 3000):
logStatWH1 = logUH1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUH1[1] * (3000 - thisTemp)/(3000 - 500)
logStatWHe1 = logUHe1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUHe1[1] * (3000 - thisTemp)/(3000 - 500)
elif (thisTemp > 3000 and thisTemp <= 8000):
logStatWH1 = logUH1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUH1[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWHe1 = logUHe1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUHe1[2] * (8000 - thisTemp)/(8000 - 3000)
elif (thisTemp > 8000 and thisTemp < 10000):
logStatWH1 = logUH1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUH1[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWHe1 = logUHe1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUHe1[3] * (10000 - thisTemp)/(10000 - 8000)
else:
#// for temperatures of greater than or equal to 10000K lburns
logStatWH1 = logUH1[4]
logStatWHe1 = logUHe1[4]
"""
logGroundPopsH1[iD] = stagePops[0][0][iD] - logStatWH1
logGroundPopsHe1[iD] = stagePops[1][0][iD] - logStatWHe1
logH2Pops[iD] = molPops[iH2 - gsFirstMol][iD]
#print("iD " , iD , " logH2 " , logH2Pops[iD])
#// if (iD%10 == 1){
#// System.out.format("%03d, %21.15f, %21.15f %n",
#// iD, logE*logGroundPopsH1[iD], logE*logGroundPopsHe1[iD]);
#// }
kapRScat = 0.0
#//System.out.println("iD iL lambda sigH1 sigHe1 ");
for iL in range(numLams):
#//
for i in range(numDeps):
sigH1[i] = 0.0
sigHe1[i] = 0.0
sigH2[i] = 0.0
#//System.out.println("Calling opacH1 from masterMetal...");
sigH1 = opacHscat(numDeps, temp, lambdaScale[iL], logGroundPopsH1)
sigHe1 = opacHescat(numDeps, temp, lambdaScale[iL], logGroundPopsHe1)
sigH2 = opacH2scat(numDeps, temp, lambdaScale[iL], logH2Pops)
for iD in range(numDeps):
kapRScat = sigH1[iD] + sigHe1[iD] + sigH2[iD]
masterRScat[iL][iD] = math.log(kapRScat)
#if ( (iD%10 == 0) and (iL%10 == 0) ):
# print("iD ", iD, " iL ", iL, " lambda ", lambdaScale[iL], math.log10(sigH1[iD]), math.log10(sigHe1[iD]), math.log10(sigH2[iD]) )
#} //iD
#} //iL
return masterRScat
def masterMetal(numDeps, numLams, temp, lambdaScale, stagePops):
"""/* Metal b-f opacity routines taken from Moog (moogjul2014/, MOOGJUL2014.tar)
Chris Sneden (Universtiy of Texas at Austin) and collaborators
http://www.as.utexas.edu/~chris/moog.html
//From Moog source file Opacitymetals.f
*/"""
#//System.out.println("masterMetal called...");
#//From Moog source file Opacitymetals.f
#// From how values such as aC1[] are used in Moog file Opacit.f to compute the total opacity
#// and then the optical depth scale, I infer that they are extinction coefficients
#// in cm^-1
#// There does not seem to be any correction for stimulated emission
logE = math.log10(math.e)
masterBF = [[0.0 for i in range(numDeps)] for j in range(numLams)]
logUC1 = [0.0 for i in range(5)]
logUMg1 = [0.0 for i in range(5)]
logUMg2 = [0.0 for i in range(5)]
logUAl1 = [0.0 for i in range(5)]
logUSi1 = [0.0 for i in range(5)]
logUSi2 = [0.0 for i in range(5)]
logUFe1 = [0.0 for i in range(5)]
logStatWC1 = 0.0
logStatWMg1 = 0.0
logStatWMg2 = 0.0
logStatWAl1 = 0.0
logStatWSi1 = 0.0
logStatWSi2 = 0.0
logStatWFe1 = 0.0
theta = 1.0
species = ""
logGroundPopsC1 = [0.0 for i in range(numDeps)]
logGroundPopsMg1 = [0.0 for i in range(numDeps)]
logGroundPopsMg2 = [0.0 for i in range(numDeps)]
logGroundPopsAl1 = [0.0 for i in range(numDeps)]
logGroundPopsSi1 = [0.0 for i in range(numDeps)]
logGroundPopsSi2 = [0.0 for i in range(numDeps)]
logGroundPopsFe1 = [0.0 for i in range(numDeps)]
#//
#// C I: Z=6 --> iZ=5:
aC1 = [0.0 for i in range(numDeps)]
#// Mg I: Z=12 --> iZ=11:
aMg1 = [0.0 for i in range(numDeps)]
#// Mg II: Z=12 --> iZ=11:
aMg2 = [0.0 for i in range(numDeps)]
#// Al I: Z=13 --> iZ=12:
aAl1 = [0.0 for i in range(numDeps)]
#// Si I: Z=14 --> iZ=13:
aSi1 = [0.0 for i in range(numDeps)]
#// Si II: Z=14 --> iZ =13:
aSi2 = [0.0 for i in range(numDeps)]
#// Fe I: Z=26 --> iZ=25
aFe1 = [0.0 for i in range(numDeps)]
species = "CI"
logUC1 = PartitionFn.getPartFn2(species)
species = "MgI"
logUMg1 = PartitionFn.getPartFn2(species)
species = "MgII"
logUMg2 = PartitionFn.getPartFn2(species)
species = "AlI"
logUAl1 = PartitionFn.getPartFn2(species)
species = "SiI"
logUSi1 = PartitionFn.getPartFn2(species)
species = "SiII"
logUSi2 = PartitionFn.getPartFn2(species)
species = "FeI"
logUFe1 = PartitionFn.getPartFn2(species)
#//System.out.println("iD PpC1 PpMg1 PpMg2 PpAl1 PpSi1 PpSi2 PpFe1");
for iD in range(numDeps):
#//neutral stage
#//Assumes ground state stat weight, g_1, is 1.0
#theta = 5040.0 / temp[0][iD]
#// U[0]: theta = 1.0, U[1]: theta = 0.5
"""
if (theta <= 0.5):
logStatWC1 = logUC1[1]
logStatWMg1 = logUMg1[1]
logStatWMg2 = logUMg2[1]
logStatWAl1 = logUAl1[1]
logStatWSi1 = logUSi1[1]
logStatWSi2 = logUSi2[1]
logStatWFe1 = logUFe1[1]
elif ( (theta < 1.0) and (theta > 0.5) ):
logStatWC1 = ( (theta-0.5) * logUC1[0] ) + ( (1.0-theta) * logUC1[1] )
#//divide by common factor of interpolation interval of 0.5 = (1.0 - 0.5):
logStatWC1 = 2.0 * logStatWC1
logStatWMg1 = ( (theta-0.5) * logUMg1[0] ) + ( (1.0-theta) * logUMg1[1] );
logStatWMg1 = 2.0 * logStatWMg1;
logStatWMg2 = ( (theta-0.5) * logUMg2[0] ) + ( (1.0-theta) * logUMg2[1] );
logStatWMg2 = 2.0 * logStatWMg2;
logStatWAl1 = ( (theta-0.5) * logUAl1[0] ) + ( (1.0-theta) * logUAl1[1] );
logStatWAl1 = 2.0 * logStatWAl1;
logStatWSi1 = ( (theta-0.5) * logUSi1[0] ) + ( (1.0-theta) * logUSi1[1] );
logStatWSi1 = 2.0 * logStatWSi1;
logStatWSi2 = ( (theta-0.5) * logUSi2[0] ) + ( (1.0-theta) * logUSi2[1] );
logStatWSi2 = 2.0 * logStatWSi2;
logStatWFe1 = ( (theta-0.5) * logUFe1[0] ) + ( (1.0-theta) * logUFe1[1] );
logStatWFe1 = 2.0 * logStatWFe1;
else:
logStatWC1 = logUC1[0]
logStatWMg1 = logUMg1[0]
logStatWMg2 = logUMg2[0]
logStatWAl1 = logUAl1[0]
logStatWSi1 = logUSi1[0]
logStatWSi2 = logUSi2[0]
logStatWFe1 = logUFe1[0]
"""
thisTemp = temp[0][iD]
#JB#
logWC1Fit = ToolBox.cubicFit(masterTemp, logUC1)
logStatWC1 = ToolBox.valueFromFit(logWC1Fit, thisTemp)
logWMg1Fit = ToolBox.cubicFit(masterTemp, logUMg1)
logStatWMg1 = ToolBox.valueFromFit(logWMg1Fit, thisTemp)
logWSi1Fit = ToolBox.cubicFit(masterTemp, logUSi1)
logStatWSi1 = ToolBox.valueFromFit(logWSi1Fit, thisTemp)
logWMg2Fit = ToolBox.cubicFit(masterTemp, logUMg2)
logStatWMg2 = ToolBox.valueFromFit(logWMg2Fit, thisTemp)
logWSi2Fit = ToolBox.cubicFit(masterTemp, logUSi2)
logStatWSi2 = ToolBox.valueFromFit(logWSi2Fit, thisTemp)
logWFe1Fit = ToolBox.cubicFit(masterTemp, logUFe1)
logStatWFe1 = ToolBox.valueFromFit(logWFe1Fit, thisTemp)
logWAl1Fit = ToolBox.cubicFit(masterTemp, logUAl1)
logStatWAl1 = ToolBox.valueFromFit(logWAl1Fit, thisTemp)
#logStatWC1Fun = spline(masterTemp,logUC1)
#logStatWC1=logStatWC1Fun(thisTemp)
#logStatWMg1Fun = spline(masterTemp,logUMg1)
#logStatWMg1=logStatWMg1Fun(thisTemp)
#logStatWMg2Fun = spline(masterTemp,logUMg2)
#logStatWMg2=logStatWMg2Fun(thisTemp)
#logStatWAl1Fun = spline(masterTemp,logUAl1)
#logStatWAl1=logStatWAl1Fun(thisTemp)
#logStatWSi1Fun = spline(masterTemp,logUSi1)
#logStatWSi1=logStatWSi1Fun(thisTemp)
#logStatWSi2Fun = spline(masterTemp,logUSi2)
#logStatWSi2=logStatWSi2Fun(thisTemp)
#logStatWFe1Fun = spline(masterTemp,logUFe1)
#logStatWFe1=logStatWFe1Fun(thisTemp)
#JB#
#// NEW Interpolation involving temperature for new partition function: lburns
thisTemp = temp[0][iD]
if (thisTemp <= 130.0):
logStatWC1 = logUC1[0]
logStatWMg1 = logUMg1[0]
logStatWMg2 = logUMg2[0]
logStatWAl1 = logUAl1[0]
logStatWSi1 = logUSi1[0]
logStatWSi2 = logUSi2[0]
logStatWFe1 = logUFe1[0]
if (thisTemp >= 10000.0):
logStatWC1 = logUC1[4]
logStatWMg1 = logUMg1[4]
logStatWMg2 = logUMg2[4]
logStatWAl1 = logUAl1[4]
logStatWSi1 = logUSi1[4]
logStatWSi2 = logUSi2[4]
logStatWFe1 = logUFe1[4]
"""
elif (thisTemp > 130 and thisTemp <= 500):
#// Add in interpolation here lburns
logStatWC1 = logUC1[1] * (thisTemp - 130)/(500 - 130) \
+ logUC1[0] * (500 - thisTemp)/(500 - 130)
logStatWMg1 = logUMg1[1] * (thisTemp - 130)/(500 - 130) \
+ logUMg1[0] * (500 - thisTemp)/(500 - 130)
logStatWMg2 = logUMg2[1] * (thisTemp - 130)/(500 - 130) \
+ logUMg2[0] * (500 - thisTemp)/(500 - 130)
logStatWAl1 = logUAl1[1] * (thisTemp - 130)/(500 - 130) \
+ logUAl1[0] * (500 - thisTemp)/(500 - 130)
logStatWSi1 = logUSi1[1] * (thisTemp - 130)/(500 - 130) \
+ logUSi1[0] * (500 - thisTemp)/(500 - 130)
logStatWSi2 = logUSi2[1] * (thisTemp - 130)/(500 - 130) \
+ logUSi2[0] * (500 - thisTemp)/(500 - 130)
logStatWFe1 = logUFe1[1] * (thisTemp - 130)/(500 - 130) \
+ logUFe1[0] * (500 - thisTemp)/(500 - 130)
elif (thisTemp > 500 and thisTemp <= 3000):
logStatWC1 = logUC1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUC1[1] * (3000 - thisTemp)/(3000 - 500)
logStatWMg1 = logUMg1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUMg1[1] * (3000 - thisTemp)/(3000 - 500)
logStatWMg2 = logUMg2[2] * (thisTemp - 500)/(3000 - 500) \
+ logUMg2[1] * (3000 - thisTemp)/(3000 - 500)
logStatWAl1 = logUAl1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUAl1[1] * (3000 - thisTemp)/(3000 - 500)
logStatWSi1 = logUSi1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUSi1[1] * (3000 - thisTemp)/(3000 - 500)
logStatWSi2 = logUSi2[2] * (thisTemp - 500)/(3000 - 500) \
+ logUSi2[1] * (3000 - thisTemp)/(3000 - 500)
logStatWFe1 = logUFe1[2] * (thisTemp - 500)/(3000 - 500) \
+ logUFe1[1] * (3000 - thisTemp)/(3000 - 500)
elif (thisTemp > 3000 and thisTemp <= 8000):
logStatWC1 = logUC1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUC1[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWMg1 = logUMg1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUMg1[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWMg2 = logUMg2[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUMg2[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWAl1 = logUAl1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUAl1[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWSi1 = logUSi1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUSi1[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWSi2 = logUSi2[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUSi2[2] * (8000 - thisTemp)/(8000 - 3000)
logStatWFe1 = logUFe1[3] * (thisTemp - 3000)/(8000 - 3000) \
+ logUFe1[2] * (8000 - thisTemp)/(8000 - 3000)
elif (thisTemp > 8000 and thisTemp < 10000):
logStatWC1 = logUC1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUC1[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWMg1 = logUMg1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUMg1[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWMg2 = logUMg2[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUMg2[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWAl1 = logUAl1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUAl1[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWSi1 = logUSi1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUSi1[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWSi2 = logUSi2[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUSi2[3] * (10000 - thisTemp)/(10000 - 8000)
logStatWFe1 = logUFe1[4] * (thisTemp - 8000)/(10000 - 8000) \
+ logUFe1[3] * (10000 - thisTemp)/(10000 - 8000)
else:
#// for temperatures greater than or equal to 10000
logStatWC1 = logUC1[4]
logStatWMg1 = logUMg1[4]
logStatWMg2 = logUMg2[4]
logStatWAl1 = logUAl1[4]
logStatWSi1 = logUSi1[4]
logStatWSi2 = logUSi2[4]
logStatWFe1 = logUFe1[4]
"""
logGroundPopsC1[iD] = stagePops[5][0][iD] - logStatWC1
logGroundPopsMg1[iD] = stagePops[11][0][iD] - logStatWMg1
logGroundPopsMg2[iD] = stagePops[11][1][iD] - logStatWMg2
logGroundPopsAl1[iD] = stagePops[12][0][iD] - logStatWAl1
logGroundPopsSi1[iD] = stagePops[13][0][iD] - logStatWSi1
logGroundPopsSi2[iD] = stagePops[13][1][iD] - logStatWSi2
logGroundPopsFe1[iD] = stagePops[25][0][iD] - logStatWFe1
#// if (iD%5 == 1){
#// System.out.format("%03d, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f %n",
#// iD, logE*(logGroundPopsC1[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsMg1[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsMg2[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsAl1[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsSi1[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsSi2[iD]+temp[1][iD]+Useful.logK()),
#// logE*(logGroundPopsFe1[iD]+temp[1][iD]+Useful.logK()));
#id loop// }
#double waveno; //cm??
#double freq, logFreq, kapBF;
#double stimEmExp, stimEmLogExp, stimEmLogExpHelp, stimEm;
#//System.out.println("iD iL lambda stimEm aC1 aMg1 aMg2 aAl1 aSi1 aSi2 aFe1 ");
for iL in range(numLams):
#print("iL ", iL)
#//
#//initialization:
for i in range(numDeps):
aC1[i] = 0.0
aMg1[i] = 0.0
aMg2[i] = 0.0
aAl1[i] = 0.0
aSi1[i] = 0.0
aSi2[i] = 0.0
aFe1[i] = 0.0
waveno = 1.0 / lambdaScale[iL] #//cm^-1??
logFreq = Useful.logC() - math.log(lambdaScale[iL])
freq = math.exp(logFreq)
#if (iL%20 == 1):
# print("freq ", freq)
stimEmLogExpHelp = Useful.logH() + logFreq - Useful.logK()
#//System.out.println("Calling opacC1 from masterMetal...");
if (freq >= 2.0761e15):
aC1 = opacC1(numDeps, temp, lambdaScale[iL], logGroundPopsC1)
if (freq >= 2.997925e+14):
#print("opacMg1 called")
aMg1 = opacMg1(numDeps, temp, lambdaScale[iL], logGroundPopsMg1)
if (freq >= 2.564306e15):
aMg2 = opacMg2(numDeps, temp, lambdaScale[iL], logGroundPopsMg2)
if (freq >= 1.443e15):
aAl1 = opacAl1(numDeps, temp, lambdaScale[iL], logGroundPopsAl1)
if (freq >= 2.997925e+14):
#print("opacSi1 called")
aSi1 = opacSi1(numDeps, temp, lambdaScale[iL], logGroundPopsSi1)
if (freq >= 7.6869872e14):
aSi2 = opacSi2(numDeps, temp, lambdaScale[iL], logGroundPopsSi2)
if (waveno >= 21000.0):
aFe1 = opacFe1(numDeps, temp, lambdaScale[iL], logGroundPopsFe1)
for iD in range(numDeps):
kapBF = 1.0e-99 #minimum safe value
stimEmLogExp = stimEmLogExpHelp - temp[1][iD]
stimEmExp = -1.0 * math.exp(stimEmLogExp)
stimEm = (1.0 - math.exp(stimEmExp)
) #//LTE correction for stimulated emission
kapBF = kapBF + aC1[iD] + aMg1[iD] + aMg2[iD] + aAl1[iD] + aSi1[
iD] + aSi2[iD] + aFe1[iD]
#kapBF = aC1[iD] + aMg2[iD] + aAl1[iD] + aSi2[iD] + aFe1[iD]
#if ( (iL%20 == 1) and (iD%10 == 1) ):
#print("iL ", iL, " iD ", iD, " stimEm ", stimEm, " kapBF ", kapBF)
# print("aMg1 ", aMg1[iD], " aSi1 ", aSi1[iD])
masterBF[iL][iD] = math.log(kapBF) + math.log(stimEm)
#// if ( (iD%10 == 0) && (iL%10 == 0) ) {
#// System.out.format("%03d, %03d, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %21.15f, %n",
#// iD, iL, lambdaScale[iL], Math.log10(stimEm), Math.log10(aC1[iD]), Math.log10(aMg1[iD]), Math.log10(aMg2[iD]), Math.log10(aAl1[iD]), Math.log10(aSi1[iD]), Math.log10(aSi2[iD]), Math.log10(aFe1[iD]));
#// }
#} //iD
#} //iL
return masterBF
