def getrMagBinary(L1, T1, g1, r1, L2, T2, g2, r2, M_H, dist, AV, extVal):
SED1 = SED()
SED1.filters = ['r_']
SED1.filterFilesRoot = filterFilesRoot
SED1.T = T1 * units.K
SED1.R = r1 * units.solRad
SED1.L = L1 * units.solLum
SED1.logg = g1
SED1.M_H = M_H
SED1.EBV = AV / RV #could use this to account for reddening in SED
SED1.initialize()
SED2 = SED()
SED2.filters = ['r_']
SED2.filterFilesRoot = filterFilesRoot
SED2.T = T2 * units.K
SED2.R = r2 * units.solRad
SED2.L = L2 * units.solLum
SED2.logg = g2
SED2.M_H = M_H
SED2.EBV = AV / RV #could use this to account for reddening in SED
SED2.initialize()
Lconst1 = SED1.getLconst()
Lconst2 = SED2.getLconst()
Ared = extVal * AV
Fv1 = SED1.getFvAB(dist * units.kpc, 'r_', Lconst=Lconst1)
Fv2 = SED2.getFvAB(dist * units.kpc, 'r_', Lconst=Lconst2)
Fv = Fv1 + Fv2
return -2.5 * np.log10(Fv) + Ared #AB magnitude
def getrMagSingle(L1, T1, g1, r1, M_H, dist, AV, extVal):
SED1 = SED()
SED1.filters = ['r_']
SED1.filterFilesRoot = filterFilesRoot
SED1.T = T1 * units.K
SED1.R = r1 * units.solRad
SED1.L = L1 * units.solLum
SED1.logg = g1
SED1.M_H = M_H
SED1.EBV = AV / RV #could use this to account for reddening in SED
SED1.initialize()
Lconst1 = SED1.getLconst()
Ared = extVal * AV
Fv = SED1.getFvAB(dist * units.kpc, 'r_', Lconst=Lconst1)
return -2.5 * np.log10(Fv) + Ared #AB magnitude
def initialize(self):
if (self.R is None): self.R = self.getRad(self.logg, self.m)
if (self.T is None): self.T = self.getTeff(self.L, self.R)
if (self.logg is None):
self.logg = self.getlogg(self.m, self.L, self.T)
#one option for getting the extinction
if (self.AV is None):
count = 0
while (self.AV is None and count < 100):
count += 1
self.AV = extinction.get_AV_infinity(self.RA,
self.Dec,
frame='icrs')
if (self.AV is None):
print("WARNING: No AV found", self.RA, self.Dec, self.AV,
count)
time.sleep(30)
#initialize the SED
self.SED = SED()
self.SED.filters = self.filters
self.SED.filterFilesRoot = self.filterFilesRoot
self.SED.T = self.T * units.K
self.SED.R = self.R * units.solRad
self.SED.L = self.L * units.solLum
self.SED.logg = self.logg
self.SED.M_H = self.M_H
self.SED.EBV = self.AV / self.RV #could use this to account for reddening in SED
self.SED.initialize()
#one option for getting the extinction
ext = F04(Rv=self.RV)
Lconst = self.SED.getLconst()
for f in self.filters:
self.Ared[f] = ext(self.wavelength[f] * units.nm) * self.AV
self.Fv[f] = self.SED.getFvAB(self.dist * units.kpc,
f,
Lconst=Lconst)
self.appMagMean[f] = -2.5 * np.log10(
self.Fv[f]) + self.Ared[f] #AB magnitude
def define_model(self):
self.user_indices = tf.placeholder(tf.int32,
shape=[None],
name='user_indices')
self.user_cdcf_indices = tf.placeholder(tf.int32,
shape=[None],
name='user_cdcf_indices')
self.item_indices = tf.placeholder(tf.int32,
shape=[None],
name='item_indices')
self.true_rating = tf.placeholder(tf.float32,
shape=[None],
name='true_ratings')
self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
self.keep_prob_layer = tf.placeholder(tf.float32,
name='keep_prob_layer')
self.domain_indices = tf.placeholder(tf.int32,
shape=[None],
name='domain_indices')
self.valid_clip = tf.placeholder(tf.float32, name='valid_clip')
self.mu_embeddings = tf.Variable(tf.constant(
[self.mu_target, self.mu_source], dtype=tf.float32),
dtype=tf.float32,
name='mu_embedding',
trainable=False)
self.user_bias_embeddings = tf.Variable(
self.initializer(shape=[self.num_users]),
dtype=tf.float32,
name='user_bias_embedding')
self.user_bias_cdcf_embeddings = tf.Variable(
tf.zeros(shape=[2 * self.num_users]),
dtype=tf.float32,
name='user_bias_embedding')
self.item_bias_embeddings = tf.Variable(
self.initializer(shape=[self.num_items]),
dtype=tf.float32,
name='item_bias_embedding')
self.ubias_embeds = tf.nn.embedding_lookup(self.user_bias_embeddings,
self.user_indices)
self.ubias_cdcf_embeds = tf.nn.embedding_lookup(
self.user_bias_cdcf_embeddings, self.user_cdcf_indices)
self.ibias_embeds = tf.nn.embedding_lookup(self.item_bias_embeddings,
self.item_indices)
self.mu_embeds = tf.nn.embedding_lookup(self.mu_embeddings,
self.domain_indices)
# create gmf object and define gmf model
if self.method == 'gcmf':
self.gcmf_model = GCMF(self.params)
self.gcmf_model.define_model(self.user_indices,
self.user_cdcf_indices,
self.item_indices, self.true_rating,
self.keep_prob, self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.gcmf_model.pred_rating
elif self.method == 'mlp':
self.mlp_model = MLP(self.params)
self.mlp_model.define_model(self.user_indices,
self.user_cdcf_indices,
self.item_indices, self.true_rating,
self.keep_prob, self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.mlp_model.pred_rating
elif self.method == 'sed':
self.sed_model = SED(self.params)
self.sed_model.define_model(self.user_indices,
self.user_cdcf_indices,
self.item_indices, self.true_rating,
self.keep_prob, self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.sed_model.pred_rating
elif self.method == 'gcmf_mlp':
self.gcmf_mlp_model = GCMF_MLP(self.params)
self.gcmf_mlp_model.define_model(self.user_indices,
self.user_cdcf_indices,
self.item_indices,
self.true_rating, self.keep_prob,
self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.gcmf_mlp_model.pred_rating
#elif self.method == 'gcmf_sed':
elif self.method == 'gcmf_sed':
self.gcmf_sed_model = GCMF_SED(self.params)
self.gcmf_sed_model.define_model(self.user_indices,
self.user_cdcf_indices,
self.item_indices,
self.true_rating, self.keep_prob,
self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.gcmf_sed_model.pred_rating
elif self.method == 'gcmf_mlp_sed':
self.gcmf_mlp_sed_model = GCMF_MLP_SED(self.params)
self.gcmf_mlp_sed_model.define_model(
self.user_indices, self.user_cdcf_indices, self.item_indices,
self.true_rating, self.keep_prob, self.keep_prob_layer,
self.domain_indices)
self.pred_rating_model = self.gcmf_mlp_sed_model.pred_rating
#====
'''
self.pred_rating = (self.pred_rating_model +
self.ubias_embeds + self.ubias_cdcf_embeds +
self.ibias_embeds +self.mu_embeds)
'''
self.pred_rating = (self.pred_rating_model)
self.pred_rating = (
(1 - self.valid_clip) * self.pred_rating +
self.valid_clip * tf.clip_by_value(
self.pred_rating, self.rating_min_val, self.rating_max_val))
print('PRED_RATING : with bias')
flux_densities = False
redshifts = [3.00,2.794,2.541,2.43,1.759,1.411,2.59,1.552,0.667,2.086,1.996,5.000,2.497,0.769,1.721,1.314]
c = const.c.value
wavelength = 1.3e-3
freq = c/wavelength
if flux_densities:
N = len(chain[0][int(burn_in*len(chain[0])):])
Temps, C_vals = [],[]
for i in range(16):
Temps.append(chain[2*i][int(burn_in*len(chain[2*i])):])
C_vals.append(chain[(2*i)+1][int(burn_in*(len(chain[(2*i)+1]))):])
SED_chain = [[] for i in range(16)]
for i in range(int(N)):
for j in range(16):
SED_chain[j].append(SED(freq,Temps[j][i],1.5,redshifts[j],C_vals[j][i],2.0, nu_cut(Temps[j][i],1.5,redshifts[j],C_vals[j][i],2.0)))
for i in SED_chain:
print "Maximum Likelihood Value and 68% Confidence Interval: ", statistics_hist(i,0.68,"stats")
#plt.figure()
#plt.hist(SED_chain[0],np.linspace(min(SED_chain[0]),max(SED_chain[0]),50))
#plt.xlabel("Flux Density (Jy)")
#plt.show()
#************************************************************************
"""
Star Formation Rate
- testing not adequate at the moment: wait for longer chain.
"""
from scipy.integrate import simps
def initialize(self):
#should I initialize the seed here?
#No I am initializing it in LSSTEBworker.py
#self.initializeSeed()
self.q = self.m2 / self.m1
self.a = self.getafromP(self.m1 * units.solMass,
self.m2 * units.solMass,
self.period * units.day).to(units.solRad).value
self.R_1 = self.r1 / self.a
self.R_2 = self.r2 / self.a
self.R_1e = self.r1 / self.Eggleton_RL(
self.m1 / self.m2, self.a * (1. - self.eccentricity))
self.R_2e = self.r2 / self.Eggleton_RL(
self.m2 / self.m1, self.a * (1. - self.eccentricity))
self.f_c = np.sqrt(self.eccentricity) * np.cos(
self.omega * np.pi / 180.)
self.f_s = np.sqrt(self.eccentricity) * np.sin(
self.omega * np.pi / 180.)
if (self.RA is None):
coord = SkyCoord(x=self.xGx,
y=self.yGx,
z=self.zGx,
unit='pc',
representation='cartesian',
frame='galactocentric')
self.RA = coord.icrs.ra.to(units.deg).value
self.Dec = coord.icrs.dec.to(units.deg).value
for f in self.filters:
self.appMagMean[f] = -999.
self.deltaMag[f] = None
self.LSS[f] = -999.
self.appMagObs[f] = [None]
self.appMagObsErr[f] = [None]
self.deltaMag[f] = 0.
self.obsDates[f] = [None]
self.eclipseDepthFrac[f] = 0.
self.appMagMean[
'r_'] = self.TRILEGALrmag #for binaries that don't pass the preCheck
self.maxDeltaMag = 0.
self.preCheckIfObservable()
if (self.observable):
if (self.T1 is None): self.T1 = self.getTeff(self.L1, self.r1)
if (self.T2 is None): self.T2 = self.getTeff(self.L2, self.r2)
if (self.g1 is None):
self.g1 = self.getlogg(self.m1, self.L1, self.T1)
if (self.g2 is None):
self.g2 = self.getlogg(self.m2, self.L2, self.T2)
self.sbratio = (self.L2 / self.r2**2.) / (self.L1 / self.r1**2.)
#one option for getting the extinction
if (self.AV is None):
count = 0
while (self.AV is None and count < 100):
count += 1
self.AV = extinction.get_AV_infinity(self.RA,
self.Dec,
frame='icrs')
if (self.AV is None):
print("WARNING: No AV found", self.RA, self.Dec,
self.AV, count)
time.sleep(30)
self.SED1 = SED()
self.SED1.filters = self.filters
self.SED1.filterFilesRoot = self.filterFilesRoot
self.SED1.T = self.T1 * units.K
self.SED1.R = self.r1 * units.solRad
self.SED1.L = self.L1 * units.solLum
self.SED1.logg = self.g1
self.SED1.M_H = self.M_H
self.SED1.EBV = self.AV / self.RV #could use this to account for reddening in SED
self.SED1.initialize()
self.SED2 = SED()
self.SED2.filters = self.filters
self.SED2.filterFilesRoot = self.filterFilesRoot
self.SED2.T = self.T2 * units.K
self.SED2.R = self.r2 * units.solRad
self.SED2.L = self.L2 * units.solLum
self.SED2.logg = self.g2
self.SED2.M_H = self.M_H
self.SED2.EBV = self.AV / self.RV #could use this to account for reddening in SED
self.SED2.initialize()
#estimate a combined Teff value, as I do in the N-body codes (but where does this comes from?)
logLb = np.log10(self.L1 + self.L2)
logRb = 0.5 * np.log10(self.r1**2. + self.r2**2.)
self.T12 = 10.**(3.762 + 0.25 * logLb - 0.5 * logRb)
#print(self.L1, self.L2, self.T1, self.T2, self.T12)
#account for reddening and the different filter throughput functions (currently related to a blackbody)
self.appMagMeanAll = 0.
#one option for getting the extinction
#ext = F04(Rv=self.RV)
ext = F04(Rv=self.RV)
#a check
# self.Ltest = self.SED.getL(self.T1*units.K, self.r1*units.solRad)
#definitely necessary for Kurucz because these models are not normalized
#for the bb I'm getting a factor of 2 difference for some reason
Lconst1 = self.SED1.getLconst()
Lconst2 = self.SED2.getLconst()
#print(np.log10(Lconst1), np.log10(Lconst2))
for f in self.filters:
#print(extinction.fitzpatrick99(np.array([self.wavelength[f]*10.]), self.AV, self.RV, unit='aa')[0] , ext(self.wavelength[f]*units.nm)*self.AV)
#self.Ared[f] = extinction.fitzpatrick99(np.array([self.wavelength[f]*10.]), self.AV, self.RV, unit='aa')[0] #or ccm89
self.Ared[f] = ext(self.wavelength[f] * units.nm) * self.AV
self.Fv1[f] = self.SED1.getFvAB(self.dist * units.kpc,
f,
Lconst=Lconst1)
self.Fv2[f] = self.SED2.getFvAB(self.dist * units.kpc,
f,
Lconst=Lconst2)
Fv = self.Fv1[f] + self.Fv2[f]
self.appMagMean[f] = -2.5 * np.log10(Fv) + self.Ared[
f] #AB magnitude
#print(self.wavelength[f], self.appMagMean[f], self.Ared[f], self.T1)
self.appMagMeanAll += self.appMagMean[f]
self.appMagMeanAll /= len(self.filters)
#check if we can observe this based on the magnitude
self.magCheckIfObservable()
#if we're using OpSim, then get the field ID
#get the field ID number from OpSim where this binary would be observed
if (self.useOpSimDates and self.observable
and self.OpSim.fieldID[0] is None):
self.OpSim.setFieldID(self.RA, self.Dec)
#this now covers the galaxy and the cluster, if available
if (self.observable and self.crowding is not None):
self.crowding.input_rFlux = self.Fv1['r_'] + self.Fv2[
'r_'] #NOTE; if I don't have a r_ band, this will crash
self.crowding.getCrowding()
for f in self.filters:
self.light_3[f] = self.crowding.backgroundFlux[f] / (
self.Fv1[f] + self.Fv2[f])
