diff --git a/scripts/ingests/sanghi23/Ingest_S23_Parameters.py b/scripts/ingests/sanghi23/Ingest_S23_Parameters.py new file mode 100644 index 000000000..6db1fcc10 --- /dev/null +++ b/scripts/ingests/sanghi23/Ingest_S23_Parameters.py @@ -0,0 +1,328 @@ +# # Ingest Fundamental Paramters from Sanghi23 + +# #SIMPLE & Astrodb Packages --- +# import logging +# from astrodb_utils import load_astrodb, AstroDBError +# from astrodb_utils.sources import find_source_in_db, ingest_names +# from simple import REFERENCE_TABLES +# #Additional Packages -- +# import os +# import pandas as pd + +# # Set up logging +# logger = logging.getLogger("astrodb_utils.beiler24") +# logger.setLevel(logging.INFO) +# logger.info(f"script using {logger.name}") +# logger.info(f"Logger level: {logging.getLevelName(logger.getEffectiveLevel()) }") + +# # Load Database +# recreate_db = True +# save_db = True + +# SCHEMA_PATH = "simple/schema.yaml" +# db = load_astrodb( +# "SIMPLE.sqlite", +# recreatedb=recreate_db, +# reference_tables=REFERENCE_TABLES, +# felis_schema=SCHEMA_PATH) + + +# # Ingest Fundamental Parameters +# #evo_cols = ["name", "name_simbadable", "ra_j2000_formula", "dec_j2000_formula", "teff_evo", "teff_evo_err", "radius_evo", "radius_evo_err", "mass_evo", "mass_evo_err", "logg_evo", "logg_evo_err"] +# evo_table = pd.read_csv('FundamentalPropertiesbyEvoModel.csv') +# modeled_parameters_evo_ingest_dict = [ +# {'sourceName': row['name'], +# 'sourceAltName': row['name_simbadable'], +# 'ra': row['ra_j2000_formula'], +# 'dec': row['dec_j2000_formula'], +# 'Radius': {'value': row['radius_evo'], 'value_error': row['radius_evo_err'], 'parameter': "radius", 'unit': 'R_jup', "model": "evolutionary"}, +# 'log_g': {'value': row['logg_evo'], 'value_error': row['logg_evo_err'], 'parameter': "log g", 'unit': 'dex', "model": "evolutionary"}, +# 'T_eff': {'value': row['teff_evo'], 'value_error': row['teff_evo_err'], 'parameter': "T eff", 'unit': 'K', "model": "evolutionary"}, +# 'Mass': {'value': row['mass_evo'], 'value_error': row['mass_evo_err'], 'parameter': "mass", 'unit': 'M_jup', "model": "evolutionary"}, +# 'reference': "Sang23" +# } for _, row in evo_table.iterrows() +# ] + +# #atmo_cols = ["name", "name_simbadable", "ra_j2000_formula", "dec_j2000_formula", "teff_atmo", "radius_atmo", "logg_atmo", "log_lbol_lsun", "log_lbol_lsun_err"] +# atmo_table = pd.read_csv('FundamentalPropertiesbyAtmoModel.csv') +# modeled_parameters_atmo_ingest_dict = [ +# {'source': atmo["name"], +# 'ra': atmo["ra_j2000_formula"], 'dec': atmo["dec_j2000_formula"], +# 'Radius': {'value': atmo["radius_atmo"], 'parameter': "radius", 'unit': 'R_jup', "model": "atmospheric"}, +# 'log_g': {'value': atmo["logg_atmo"], 'parameter': "log g", 'unit': 'dex', "model": "atmospheric"}, +# 'T_eff': {'value': atmo["teff_atmo"], 'parameter': "T eff", 'unit': 'K', "model": "atmospheric"}, +# 'log_L_bol': {'value': atmo["log_lbol_lsun"], 'value_error': atmo["log_lbol_lsun_err"], 'parameter': "L bol", 'unit': 'dex', "model": "atmospheric"}, +# 'reference': "Sang23" #confirm this +# } for _, atmo in atmo_table.iterrows() +# ] + +# def find_source_name(db, source_name, source_alt_name, ra, dec, reference): +# found_source = find_source_in_db(db, source_name, ra=ra, dec=dec, ra_col_name = "ra", dec_col_name = "dec") +# if len(found_source) > 0: +# source_name = found_source[0] + +# else: +# print(f"Source {source_name} not found in database. Trying with Simbad name") +# found_source = find_source_in_db(db, source_alt_name, ra=ra, dec=dec, ra_col_name = "ra", dec_col_name = "dec") +# if len(found_source) > 0: +# print(f"Found with simbad name {source_alt_name}. Ingesting alternative name.") +# ingest_names(db, found_source[0], source_name) +# source_name = found_source[0] +# else: +# print(f"Source {source_name} not found. Skipping for now.") +# source_name = None + + +# print(f'Found correct source name, saving as {source_name}') +# return source_name + + + +# for source in modeled_parameters_evo_ingest_dict: +# found_name = find_source_name(db, source['sourceName'], source['sourceAltName'], source['ra'], source['dec'], source['reference']) +# source['source'] = found_name +# if source['source'] is None: +# print(f"Source {source['sourceName']} not found in database. Skipping for now.") + + +# # Ingest Parameters ---- +# def ingest_parameters(mode, source): +# """ +# Ingest parameters into the database. +# """ +# # Check if source exists in the database +# source_exists = db.Sources.select().where(db.Sources.c.source == source['source']).fetchone() +# if not source_exists: +# print(f"Source {source['source']} not found in the database. Skipping.") +# return + +# # Ingest parameters +# value_types_evo = ['Radius', 'log_g', 'T_eff', 'Mass'] +# value_types_atmo = ['Radius', 'log_g', 'T_eff', 'log_L_bol'] + + +# for value_type in value_types_evo: +# if source[value_type]['value'] is not None: +# db.ModeledParameters.insert().values({'source': source['source'], **source[value_type], 'reference': "Sang23"}) +# print(f"Ingested {value_type} for {source['source']}") + + +# with db.engine.connect() as conn: +# #Adding Evo Model Parameters +# for row in source: +# if row["source"] is not None: +# source_exists = conn.execute(db.Sources.select().where(db.Sources.c.source == row["source"])).fetchone() + +# if source_exists: + +# if mode == "evolutionary": +# for value_type in value_types_evo: +# if row[value_type]['value'] is not None: +# conn.execute(db.ModeledParameters.insert().values({'source': row['source'], **row[value_type], 'reference': "Sang23"})) +# elif mode == "atmospheric": +# for value_type in value_types_atmo: +# if row[value_type]['value'] is not None: +# conn.execute(db.ModeledParameters.insert().values({'source': row['source'], **row[value_type], 'reference': "Sang23"})) +# conn.commit() + +# #Call Functions ---- +# ingest_parameters(mode = "evolutionary", +# source=modeled_parameters_evo_dict) + +# ingest_parameters(mode = "atmospheric", +# source=modeled_parameters_atmo_dict) + +# # Save to Database, Writes the JSON Files +# if save_db: +# db.save_database(directory="data/") + + +# Ingest Fundamental Parameters from Sanghi23 + +# SIMPLE & Astrodb Packages +import logging +from astrodb_utils import load_astrodb, AstroDBError +from astrodb_utils.sources import find_source_in_db, ingest_names +from simple import REFERENCE_TABLES + +# Additional Packages +import os +import pandas as pd +import numpy as np + +# Set up logging +logger = logging.getLogger("astrodb_utils.sanghi23") # Updated logger name for clarity +logger.setLevel(logging.INFO) +logger.info(f"Script using {logger.name}") +logger.info(f"Logger level: {logging.getLevelName(logger.getEffectiveLevel())}") + +# Load Database +recreate_db = True +save_db = True + +SCHEMA_PATH = "simple/schema.yaml" +db = load_astrodb( + "SIMPLE.sqlite", + recreatedb=recreate_db, + reference_tables=REFERENCE_TABLES, + felis_schema=SCHEMA_PATH +) + +# Reference for all parameters +ref = "Sang23" + +# Load data files +evo_table = pd.read_csv('FundamentalPropertiesbyEvoModel.csv') +atmo_table = pd.read_csv('FundamentalPropertiesbyAtmoModel.csv') + +def find_source_name(db, source_name, ra, dec): + logger.info(f"Looking for source {source_name} in database") + + # Try to find the source by primary name + found_source = find_source_in_db(db, source_name, ra=ra, dec=dec, ra_col_name="ra", dec_col_name="dec") + if len(found_source) > 0: + logger.info(f"Found source {source_name} in database") + return found_source[0] + + logger.warning(f"Source {source_name} not found in database.") + return None + +def create_dict(row, model_type): + if model_type == "evolutionary": + return { + 'sourceName': row['name'], + 'sourceAltName': row['name_simbadable'], + 'ra': row['ra_j2000_formula'], + 'dec': row['dec_j2000_formula'], + 'parameters': { + 'Radius': { + 'value': row['radius_evo'], + 'value_error': row['radius_evo_err'], + 'parameter': "radius", + 'unit': 'R_jup', + 'model': "evolutionary" + }, + 'log_g': { + 'value': row['logg_evo'], + 'value_error': row['logg_evo_err'], + 'parameter': "log g", + 'unit': 'dex', + 'model': "evolutionary" + }, + 'T_eff': { + 'value': row['teff_evo'], + 'value_error': row['teff_evo_err'], + 'parameter': "T eff", + 'unit': 'K', + 'model': "evolutionary" + }, + 'Mass': { + 'value': row['mass_evo'], + 'value_error': row['mass_evo_err'], + 'parameter': "mass", + 'unit': 'M_jup', + 'model': "evolutionary" + } + } + } + + elif model_type == "atmospheric": + return { + 'sourceName': row['name'], + 'sourceAltName': row.get('name_simbadable', row['name']), # Fallback if not present + 'ra': row['ra_j2000_formula'], + 'dec': row['dec_j2000_formula'], + 'parameters': { + 'Radius': { + 'value': row['radius_atmo'], + 'value_error': None, + 'parameter': "radius", + 'unit': 'R_jup', + 'model': "atmospheric" + }, + 'log_g': { + 'value': row['logg_atmo'], + 'value_error': None, + 'parameter': "log g", + 'unit': 'dex', + 'model': "atmospheric" + }, + 'T_eff': { + 'value': row['teff_atmo'], + 'value_error': None, + 'parameter': "T eff", + 'unit': 'K', + 'model': "atmospheric" + }, + 'log_L_bol': { + 'value': row['log_lbol_lsun'], + 'value_error': row['log_lbol_lsun_err'], + 'parameter': "L bol", + 'unit': 'dex', + 'model': "atmospheric" + } + } + } + else: + logger.error(f"Unknown model type: {model_type}") + return None + +def ingest_parameters(db, param_list, reference): + with db.engine.connect() as conn: + for data in param_list: + # Find the database source name + source_name = find_source_name( + db, + data['sourceName'], + data['ra'], + data['dec'] + ) + if source_name is None: + logger.warning(f"Source {data['sourceName']} not found. Skipping.") + continue + + # Insert each parameter + for param_type, param_data in data['parameters'].items(): + # Skip if value is None or NaN + if param_data['value'] is None: + logger.info(f"Skipping {param_type} for {source_name}: NaN value found") + continue + + # Prepare values for insertion + insert_data = { + 'source': source_name, + 'parameter': param_data['parameter'], + 'value': param_data['value'], + 'value_error': param_data['value_error'], + 'unit': param_data['unit'], + 'model': param_data['model'], + 'reference': reference + } + + # Insert into ModeledParameters table + try: + conn.execute(db.ModeledParameters.insert().values(insert_data)) + logger.info(f"Inserted {param_type} for {source_name}") + except Exception as e: + logger.error(f"Error inserting {param_type} for {source_name}: {e}") + + # Commit all changes at once + conn.commit() + logger.info("All parameters committed to database") + + +# Prepare data for ingestion +evo_data = [create_dict(row, "evolutionary") for _, row in evo_table.iterrows()] +atmo_data = [create_dict(row, "atmospheric") for _, row in atmo_table.iterrows()] + +# Ingest the data +logger.info("Ingesting evolutionary model parameters") +ingest_parameters(db, evo_data, ref) + +logger.info("Ingesting atmospheric model parameters") +ingest_parameters(db, atmo_data, ref) + +# Save to Database, Writes the JSON Files +if save_db: + logger.info("Saving database") + db.save_database(directory="data/") \ No newline at end of file