def main():
#Use argparse to determine if we've specified a config file
import argparse
parser = argparse.ArgumentParser(prog="plotly_model.py", description="Plot the model and residuals using plot.ly")
parser.add_argument("json", help="*.json file describing the model.")
parser.add_argument("params", help="*.yaml file specifying run parameters.")
# parser.add_argument("-o", "--output", help="*.html file for output")
args = parser.parse_args()
import json
import yaml
if args.json: #
#assert that we actually specified a *.json file
if ".json" not in args.json:
import sys
sys.exit("Must specify a *.json file.")
if args.params: #
#assert that we actually specified a *.yaml file
if ".yaml" in args.params:
yaml_file = args.params
f = open(args.params)
config = yaml.load(f)
f.close()
else:
import sys
sys.exit("Must specify a *.yaml file.")
yaml_file = args.params
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
#Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config['data'], orders=config['orders'])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config['HDF5_path'])
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument, myHDF5Interface)
for model in myModel.OrderModels:
#Get the data
wl, fl = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get residuals
residuals = model.get_residuals()
name = "Order {}".format(model.order)
url = plotly_order(name, wl, fl, flm, residuals)
print(url)
def main():
#Use argparse to determine if we've specified a config file
import argparse
parser = argparse.ArgumentParser(prog="flot_model.py", description="Plot the model and residuals using flot.")
parser.add_argument("json", help="*.json file describing the model.")
parser.add_argument("params", help="*.yaml file specifying run parameters.")
# parser.add_argument("-o", "--output", help="*.html file for output")
args = parser.parse_args()
import json
import yaml
if args.json: #
#assert that we actually specified a *.json file
if ".json" not in args.json:
import sys
sys.exit("Must specify a *.json file.")
if args.params: #
#assert that we actually specified a *.yaml file
if ".yaml" in args.params:
yaml_file = args.params
f = open(args.params)
config = yaml.load(f)
f.close()
else:
import sys
sys.exit("Must specify a *.yaml file.")
yaml_file = args.params
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
#Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config['data'], orders=config['orders'])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config['HDF5_path'])
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument, myHDF5Interface)
for model in myModel.OrderModels:
#If an order has regions, read these out from model_final.json
region_dict = model.get_regions_dict()
print("Region dict", region_dict)
#loop through these to determine the wavelength of each
wl_regions = [value["mu"] for value in region_dict.values()]
#Make vertical markings at the location of the wl_regions.
#Get the data, sigmas, and mask
wl, fl, sigma, mask = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get chebyshev
cheb = model.get_Cheb()
name = "Order {}".format(model.order)
plot_data = order_json(wl, fl, sigma, mask, flm, cheb)
plot_data.update({"wl_regions":wl_regions})
print(plot_data['wl_regions'])
render_template(base, plot_data)
def test_from_json(self):
newModel = Model.from_json("final_model.json", self.DataSpectrum,
self.Instrument, self.HDF5Interface)
import numpy as np
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, SPEX, HDF5Interface
from StellarSpectra import utils
myDataSpectrum = DataSpectrum.open("../../data/WASP14/WASP14-2009-06-14.hdf5", orders=np.array([21, 22, 23]))
myInstrument = TRES()
myHDF5Interface = HDF5Interface("../../libraries/Kurucz_TRES.hdf5")
# Load a model using the JSON file
# Taken from:
# /n/home07/iczekala/StellarSpectra/output/WASP14/Kurucz/21_22_23/logg/cov/2014-08-06/run18
myModel = Model.from_json("WASP14_Kurucz_logg_model_final.json", myDataSpectrum, myInstrument, myHDF5Interface)
myOrderModel = myModel.OrderModels[1]
model_flux = myOrderModel.get_spectrum()
spec = myModel.get_data()
wl = spec.wls[1]
fl = spec.fls[1]
model_fl = myOrderModel.get_spectrum()
residuals = fl - model_fl
mask = spec.masks[1]
cov = myModel.OrderModels[1].get_Cov().todense()
draws = utils.random_draws(cov, num=50)
import numpy as np
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
from StellarSpectra import utils
myDataSpectrum = DataSpectrum.open("../../data/WASP14/WASP14-2009-06-14.hdf5",
orders=np.array([21, 22, 23]))
myInstrument = TRES()
myHDF5Interface = HDF5Interface("../../libraries/PHOENIX_TRES_F.hdf5")
#Load a model using the JSON file
myModel = Model.from_json("WASP14_PHOENIX_model0_final.json", myDataSpectrum,
myInstrument, myHDF5Interface)
myOrderModel = myModel.OrderModels[1]
model_flux = myOrderModel.get_spectrum()
spec = myModel.get_data()
wl = spec.wls[1]
fl = spec.fls[1]
model_fl = myOrderModel.get_spectrum()
residuals = fl - model_fl
mask = spec.masks[1]
cov = myModel.OrderModels[1].get_Cov().todense()
np.save("PHOENIX_covariance_matrix.npy", cov)
myHDF5Interface = HDF5Interface(config['HDF5_path'])
stellar_Starting = config['stellar_params']
stellar_tuple = C.dictkeys_to_tuple(stellar_Starting)
cheb_Starting = config['cheb_params']
cheb_tuple = ("logc0", "c1", "c2", "c3")
cov_Starting = config['cov_params']
cov_tuple = C.dictkeys_to_cov_global_tuple(cov_Starting)
region_tuple = ("h", "loga", "mu", "sigma")
region_MH_cov = np.array([0.05, 0.04, 0.02, 0.02])**2 * np.identity(len(region_tuple))
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument, myHDF5Interface)
model = myModel.OrderModels[0]
#Get the data
wl, fl = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get residuals
residuals = model.get_residuals()
#Get the Chebyshev spectrum
cheb = model.get_Cheb()
import numpy as np
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import SPEX, HDF5Interface
from StellarSpectra import utils
myDataSpectrum = DataSpectrum.open("../../data/Gl51/Gl51RA.hdf5", orders=np.array([0]))
myInstrument = SPEX()
myHDF5Interface = HDF5Interface("../../libraries/PHOENIX_SPEX_M.hdf5")
#Load a model using the JSON file
#Taken from:
# /home/ian/Grad/Research/Disks/StellarSpectra/output/Gl51/PHOENIX/RA/region/logg/4_8sig/
myModel = Model.from_json("Gl51_model0_final.json", myDataSpectrum, myInstrument, myHDF5Interface)
myOrderModel = myModel.OrderModels[0]
model_flux = myOrderModel.get_spectrum()
spec = myModel.get_data()
wl = spec.wls[0]
fl = spec.fls[0]
model_fl = myOrderModel.get_spectrum()
residuals = fl - model_fl
mask = spec.masks[0]
cov = myModel.OrderModels[0].get_Cov().todense()
np.save("Gl51_covariance_matrix.npy", cov)
import sys
sys.exit()
def main():
#Use argparse to determine if we've specified a config file
import argparse
parser = argparse.ArgumentParser(
prog="flot_model.py",
description="Plot the model and residuals using flot.")
parser.add_argument("json", help="*.json file describing the model.")
parser.add_argument("params",
help="*.yaml file specifying run parameters.")
# parser.add_argument("-o", "--output", help="*.html file for output")
args = parser.parse_args()
import json
import yaml
if args.json: #
#assert that we actually specified a *.json file
if ".json" not in args.json:
import sys
sys.exit("Must specify a *.json file.")
if args.params: #
#assert that we actually specified a *.yaml file
if ".yaml" in args.params:
yaml_file = args.params
f = open(args.params)
config = yaml.load(f)
f.close()
else:
import sys
sys.exit("Must specify a *.yaml file.")
yaml_file = args.params
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
#Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config['data'],
orders=config['orders'])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config['HDF5_path'])
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument,
myHDF5Interface)
for model in myModel.OrderModels:
#If an order has regions, read these out from model_final.json
region_dict = model.get_regions_dict()
print("Region dict", region_dict)
#loop through these to determine the wavelength of each
wl_regions = [value["mu"] for value in region_dict.values()]
#Make vertical markings at the location of the wl_regions.
#Get the data, sigmas, and mask
wl, fl, sigma, mask = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get chebyshev
cheb = model.get_Cheb()
name = "Order {}".format(model.order)
plot_data = order_json(wl, fl, sigma, mask, flm, cheb)
plot_data.update({"wl_regions": wl_regions})
print(plot_data['wl_regions'])
render_template(base, plot_data)
def main():
#Use argparse to determine if we've specified a config file
import argparse
parser = argparse.ArgumentParser(
prog="plotly_model.py",
description="Plot the model and residuals using plot.ly")
parser.add_argument("json", help="*.json file describing the model.")
parser.add_argument("params",
help="*.yaml file specifying run parameters.")
# parser.add_argument("-o", "--output", help="*.html file for output")
args = parser.parse_args()
import json
import yaml
if args.json: #
#assert that we actually specified a *.json file
if ".json" not in args.json:
import sys
sys.exit("Must specify a *.json file.")
if args.params: #
#assert that we actually specified a *.yaml file
if ".yaml" in args.params:
yaml_file = args.params
f = open(args.params)
config = yaml.load(f)
f.close()
else:
import sys
sys.exit("Must specify a *.yaml file.")
yaml_file = args.params
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
#Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config['data'],
orders=config['orders'])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config['HDF5_path'])
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument,
myHDF5Interface)
for model in myModel.OrderModels:
#Get the data
wl, fl = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get residuals
residuals = model.get_residuals()
name = "Order {}".format(model.order)
url = plotly_order(name, wl, fl, flm, residuals)
print(url)
def test_from_json(self):
newModel = Model.from_json("final_model.json", self.DataSpectrum, self.Instrument, self.HDF5Interface)
import numpy as np
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, SPEX, HDF5Interface
from StellarSpectra import utils
myDataSpectrum = DataSpectrum.open("../../data/WASP14/WASP14-2009-06-14.hdf5",
orders=np.array([21, 22, 23]))
myInstrument = TRES()
myHDF5Interface = HDF5Interface("../../libraries/Kurucz_TRES.hdf5")
#Load a model using the JSON file
#Taken from:
#/n/home07/iczekala/StellarSpectra/output/WASP14/Kurucz/21_22_23/logg/cov/2014-08-06/run18
myModel = Model.from_json("WASP14_Kurucz_logg_model_final.json",
myDataSpectrum, myInstrument, myHDF5Interface)
myOrderModel = myModel.OrderModels[1]
model_flux = myOrderModel.get_spectrum()
spec = myModel.get_data()
wl = spec.wls[1]
fl = spec.fls[1]
model_fl = myOrderModel.get_spectrum()
residuals = fl - model_fl
mask = spec.masks[1]
cov = myModel.OrderModels[1].get_Cov().todense()
draws = utils.random_draws(cov, num=50)
#Use the model_final.json to figure out how many orders there are
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
#Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config['data'],
orders=config['orders'])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config['HDF5_path'])
myModel = Model.from_json(args.run + "/model_final.json", myDataSpectrum,
myInstrument, myHDF5Interface)
orders = [orderModel.order for orderModel in myModel.OrderModels]
flot_plots = {22: "Hi"}
#If the Jinja templater is going to work, it needs a list of orders. It also needs a list of how many regions
# are in each order
# each order, there is dictionary
#of global
#Set the categories as the decomposition of the run directory, excluding
#output and the "run00" directory.
#For example, output/WASP14/Kurucz/22/run01 becomes categories="WASP14 Kurucz 22"
categories = " ".join(args.run.split("/")[1:-1])
templateVars = {
myHDF5Interface = HDF5Interface(config['HDF5_path'])
stellar_Starting = config['stellar_params']
stellar_tuple = C.dictkeys_to_tuple(stellar_Starting)
cheb_Starting = config['cheb_params']
cheb_tuple = ("logc0", "c1", "c2", "c3")
cov_Starting = config['cov_params']
cov_tuple = C.dictkeys_to_cov_global_tuple(cov_Starting)
region_tuple = ("h", "loga", "mu", "sigma")
region_MH_cov = np.array([0.05, 0.04, 0.02, 0.02])**2 * np.identity(
len(region_tuple))
myModel = Model.from_json(args.json, myDataSpectrum, myInstrument,
myHDF5Interface)
model = myModel.OrderModels[0]
#Get the data
wl, fl = model.get_data()
#Get the model flux
flm = model.get_spectrum()
#Get residuals
residuals = model.get_residuals()
#Get the Chebyshev spectrum
cheb = model.get_Cheb()
import numpy as np
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
from StellarSpectra import utils
myDataSpectrum = DataSpectrum.open("../../data/WASP14/WASP14-2009-06-14.hdf5", orders=np.array([21,22,23]))
myInstrument = TRES()
myHDF5Interface = HDF5Interface("../../libraries/PHOENIX_TRES_F.hdf5")
#Load a model using the JSON file
myModel = Model.from_json("WASP14_PHOENIX_model0_final.json", myDataSpectrum, myInstrument, myHDF5Interface)
myOrderModel = myModel.OrderModels[1]
model_flux = myOrderModel.get_spectrum()
spec = myModel.get_data()
wl = spec.wls[1]
fl = spec.fls[1]
model_fl = myOrderModel.get_spectrum()
residuals = fl - model_fl
mask = spec.masks[1]
cov = myModel.OrderModels[1].get_Cov().todense()
np.save("PHOENIX_covariance_matrix.npy", cov)
import sys; sys.exit()
# Use the model_final.json to figure out how many orders there are
from StellarSpectra.model import Model
from StellarSpectra.spectrum import DataSpectrum
from StellarSpectra.grid_tools import TRES, HDF5Interface
# Figure out what the relative path is to base
import StellarSpectra
base = StellarSpectra.__file__[:-26]
myDataSpectrum = DataSpectrum.open(base + config["data"], orders=config["orders"])
myInstrument = TRES()
myHDF5Interface = HDF5Interface(base + config["HDF5_path"])
myModel = Model.from_json(args.run + "/model_final.json", myDataSpectrum, myInstrument, myHDF5Interface)
orders = [orderModel.order for orderModel in myModel.OrderModels]
flot_plots = {22: "Hi"}
# If the Jinja templater is going to work, it needs a list of orders. It also needs a list of how many regions
# are in each order
# each order, there is dictionary
# of global
# Set the categories as the decomposition of the run directory, excluding
# output and the "run00" directory.
# For example, output/WASP14/Kurucz/22/run01 becomes categories="WASP14 Kurucz 22"
categories = " ".join(args.run.split("/")[1:-1])
