mors.baraffe

def BaraffeLoadTrack(Mstar, pre_interp = True, tmin = None, tmax = None):
    """Load a baraffe track into memory and optionally interpolate it into a fine time-grid

    Parameters
    ----------
    Mstar : float
        Star mass (in unit of solar mass)
        It assumes the value has been checked and matches with the mass grid.
    pre_interp : bool
        Pre-interpolate the tracks onto a higher resolution time-grid
    tmin : float
        Minimum value of the temporal grid
    tmax : float
        Maximum value of the temporal grid

    Returns
    -------
    track : dict
        Dictionary containing track data
    """

    # Load data
    formatted_mass = f"{Mstar:.3f}".replace('.', 'p')
    filename = f'BHAC15-M{formatted_mass}.txt'
    path = (FWL_DATA_DIR / 'stellar_evolution_tracks' / 'Baraffe' / filename)
    if not path.exists():
        raise IOError(
            "Cannot find Baraffe track file {path}. "
            "Did you set the FWL_DATA environment variable? "
            "Did you run `mors dowload ...` to get access to the Baraffe track data?"
        )

    data = np.loadtxt(path, skiprows=1).T

    # Parse data
    t =     data[1]
    Teff =  data[2]
    Lstar = data[3]
    Rstar = data[5]

    # Pre-interpolate in time if required
    if pre_interp:
        # Params for interpolation
        grid_count = 5e4
        if tmin==None: tmin = t[0]
        if tmax==None: tmax = t[-1]

        # Do interpolation
        #log.info("Interpolating stellar track onto a grid of size %d" % grid_count)
        interp_Teff =   PchipInterpolator(t,Teff)
        interp_Lstar =  PchipInterpolator(t,Lstar)
        interp_Rstar =  PchipInterpolator(t,Rstar)

        new_t = np.logspace(tmin, tmax, int(grid_count))
        new_t = np.log10(new_t)
        new_Teff =  interp_Teff(new_t)
        new_Lstar = interp_Lstar(new_t)
        new_Rstar = interp_Rstar(new_t)

        track = {
            't':        10.0**new_t,      # yr
            'Teff':     new_Teff,         # K
            'Lstar':    10.0**new_Lstar,  # L_sun
            'Rstar':    new_Rstar         # R_sun
        }
    else:
        track = {
            't':        10.0**t,      # yr
            'Teff':     Teff,         # K
            'Lstar':    10.0**Lstar,  # L_sun
            'Rstar':    Rstar         # R_sun
        }

    return track

def ModernSpectrumLoad(input_spec_file: str, output_spec_file: str):
    """Copy file and load modern spectrum into memory.

    Scaled to 1 AU from the star.

    Parameters
    ----------
    input_spec_file : str
        Path to input spectral file
    output_spec_file : str
        Path to copied spectral file

    Returns
    -------
    spec_wl : np.array[float]
        Wavelength [nm]
    spec_fl : np.array[float]
        Flux [erg s-1 cm-2 nm-1]
    """

    if os.path.isfile(input_spec_file):
        # Copy modern spectrum file to output directory as -1.sflux.
        copy_file = shutil.copyfile(input_spec_file, output_spec_file)

        # Load file
        spec_data = np.loadtxt(copy_file, skiprows=2,delimiter='\t').T
        spec_wl = spec_data[0]
        spec_fl = spec_data[1]
    else:
        raise FileNotFoundError(f"Cannot find stellar spectrum at '{input_spec_file}'")


    #Old log print in PROTEUS
    #binwidth_wl = spec_wl[1:] - spec_wl[0:-1]
    #log.debug("Modern spectrum statistics:")
    #log.debug("\t Flux \n\t\t (min, max) = (%1.2e, %1.2e) erg s-1 cm-2 nm-1" % (np.amin(spec_fl),np.amax(spec_fl)))
    #log.debug("\t Wavelength \n\t\t (min, max) = (%1.2e, %1.2e) nm" % (np.amin(spec_wl),np.amax(spec_wl)))
    #log.debug("\t Bin width \n\t\t (min, median, max) = (%1.2e, %1.2e, %1.2e) nm" % (np.amin(binwidth_wl),np.median(binwidth_wl),np.amax(binwidth_wl)))

    return spec_wl, spec_fl