ACID-code 0.0.0__py3-none-any.whl → 0.1.0__py3-none-any.whl

ACID_code/ACID.py

@@ -2,8 +2,8 @@ import numpy as np
 import emcee
 import matplotlib.pyplot as plt
 from scipy.optimize import minimize
-from astropy.io import  fits
-import LSD_func_faster as LSD
+from astropy.io import fits
+import ACID_code.LSD_func_faster as LSD
 import glob
 from scipy.interpolate import interp1d
 from scipy.signal import find_peaks
@@ -11,6 +11,8 @@ import multiprocessing as mp
 from functools import partial
 from multiprocessing import Pool
 from statistics import stdev
+import time
+import warnings
 
 from math import log10, floor
 
@@ -29,8 +31,6 @@ directory = '/Users/lucydolan/Starbase/HD189733 old/HD189733/'
 # run_name = input('Input nickname for this version of code (for saving figures): ')
 run_name = 'test'
 
-ccf_rvs = []
-
 def findfiles(directory, file_type):
 
     filelist1=glob.glob('%s/*/*%s**A_corrected*.fits'%(directory, file_type))    #finding corrected spectra
@@ -129,8 +129,8 @@ def read_in_frames(order, filelist, file_type):
             if i+binsize<len(reference_wave):
                 waves = reference_wave[i:i+binsize]
                 flux = div_frame[i:i+binsize]
-                waves = waves[abs(flux-np.median(div_frame))<0.1]
-                flux = flux[abs(flux-np.median(div_frame))<0.1]
+                waves = waves[abs(flux-np.median(flux))<0.1]
+                flux = flux[abs(flux-np.median(flux))<0.1]
                 binned.append(np.median(flux))
                 binned_waves.append(np.median(waves))
 
@@ -150,6 +150,19 @@ def read_in_frames(order, filelist, file_type):
 
     return frame_wavelengths, frames, errors, sns, telluric_spec
 
+def calc_deltav(wavelengths):
+    """Calculates velocity pixel size
+
+    Calculates the velocity pixel size for the LSD velocity grid based off the spectral wavelengths.
+
+    Args:
+        wavelengths (array): Wavelengths for ACID input spectrum (in Angstroms).
+        
+    Returns:
+        float: Velocity pixel size in km/s
+    """ 
+    resol1 = (wavelengths[-1]-wavelengths[0])/len(wavelengths)
+    return resol1/(wavelengths[0]+((wavelengths[-1]-wavelengths[0])/2))*2.99792458e5
 
 def combine_spec(wavelengths_f, spectra_f, errors_f, sns_f):
 
@@ -157,6 +170,10 @@ def combine_spec(wavelengths_f, spectra_f, errors_f, sns_f):
     #combine all spectra to one spectrum
     for n in range(len(wavelengths_f)):
 
+        global reference_wave
+        idx_ref = (sns_f==np.max(sns_f))
+        reference_wave = wavelengths_f[idx_ref][0]
+
         idx = np.where(wavelengths_f[n] != 0)[0]
 
         f2 = interp1d(wavelengths_f[n][idx], spectra_f[n][idx], kind = 'linear', bounds_error=False, fill_value = 'extrapolate')
@@ -256,7 +273,7 @@ def log_likelihood(theta, x, y, yerr):
 
     return lnlike
 
-## imposes the prior restrictions on the inputs - rejects if profile point if less than -10 or greater than 0.5.
+## imposes the prior restrictions on the inputs - rejects if profile point is less than -10 or greater than 0.5.
 def log_prior(theta):
 
     check = 0
@@ -269,7 +286,6 @@ def log_prior(theta):
             else:
                 check = 1
 
-
     if check==0:
 
         # excluding the continuum points in the profile (in flux)
@@ -305,67 +321,41 @@ def residual_mask(wavelengths, data_spec_in, data_err, initial_inputs, poly_ord,
     a = 2/(np.max(wavelengths)-np.min(wavelengths))
     b = 1 - a*np.max(wavelengths)
 
-    # plt.figure()
     mdl1=0
     for i in range(k_max,len(initial_inputs)-1):
         mdl1 = mdl1 + (initial_inputs[i]*((wavelengths*a)+b)**(i-k_max))
 
     mdl1 = mdl1 * initial_inputs[-1]
 
-    # residuals = data_spec_in/mdl1 -1
-    # ### finds consectuative sections where at least 40 points have no conitnuum points in between - these are masked
-    # flag = ['False']*len(residuals)
-    # flagged = []
-    # for i in range(len(residuals)):
-    #     if abs(residuals[i])>0.1:
-    #         flag[i] = 'True'
-    #         if i>0 and flag[i-1] == 'True':
-    #             flagged.append(i-1)
-    #     else:
-    #         if len(flagged)>0:
-    #             flagged.append(i-1)
-    #             # print(abs(np.median(residuals[flagged[0]:flagged[-1]])))
-    #             if len(flagged)<300:
-    #                 for no in flagged:
-    #                     flag[no] = 'False'
-    #             else:
-    #                 idx = np.logical_and(wavelengths>=wavelengths[np.min(flagged)]-1, wavelengths<=wavelengths[np.max(flagged)]+1)
-    #                 data_err[idx]=10000000000000000000
-    #         flagged = []
-
     residuals = (data_spec_in - np.min(data_spec_in))/(np.max(data_spec_in)-np.min(data_spec_in)) - (forward - np.min(forward))/(np.max(forward)-np.min(forward)) 
 
+    data_err_compare = data_err.copy()
+    
     ### finds consectuative sections where at least pix_chunk points have residuals greater than 0.25 - these are masked
-    flag = ['False']*len(residuals)
-    flagged = []
-    for i in range(len(residuals)):
-        if abs(residuals[i])>(dev_perc/100):
-            flag[i] = 'True'
-            if i>0 and (flag[i-1] == 'True' or flag[i-2] == 'True'):
-                flagged.append(i-1)
-        else:
-            if len(flagged)>0:
-                flagged.append(i-1)
-                if len(flagged)<pix_chunk or abs(np.mean(residuals[flagged[0]:flagged[-1]]))<0.45:
-                    for no in flagged:
-                        flag[no] = 'False'
-                else:
-                    idx = np.logical_and(wavelengths>=wavelengths[np.min(flagged)]-1, wavelengths<=wavelengths[np.max(flagged)]+1)
-                    data_err[idx]=10000000000000000000
-            flagged = []
+    idx = (abs(residuals)>dev_perc/100)
+
+    flag_min = 0
+    flag_max = 0
+    for value in range(len(idx)):
+        if idx[value] == True and flag_min <= value:
+            flag_min = value
+            flag_max = value
+        elif idx[value] == True and flag_max < value:
+            flag_max = value
+        elif idx[value] == False and flag_max-flag_min>=pix_chunk:
+            data_err[flag_min:flag_max]=10000000000000000000
+            flag_min = value
+            flag_max = value
 
     ##############################################
     #                  TELLURICS                 #   
     ##############################################
 
-    ## masking tellurics
-
-    limit_wave =21/2.99792458e5 #needs multiplied by wavelength to give actual limit
-    limit_pix = limit_wave/((max(wavelengths)-min(wavelengths))/len(wavelengths))
+    # data_err_compare = data_err.copy()
 
-    
+    ## masking tellurics
     for line in tell_lines:
-        limit = limit_wave*line +3
+        limit = (21/2.99792458e5)*line +3
         idx = np.logical_and((line-limit)<=wavelengths, wavelengths<=(limit+line))
         data_err[idx] = 1000000000000000000
 
@@ -398,7 +388,7 @@ def residual_mask(wavelengths, data_spec_in, data_err, initial_inputs, poly_ord,
 
     return data_err, np.concatenate((profile, poly_inputs)), residual_masks
 
-def get_profiles(all_frames, counter, order, poly_cos):
+def get_profiles(all_frames, order, poly_cos, continuum_error, counter):
     flux = frames[counter]
     error = frame_errors[counter]
     wavelengths = frame_wavelengths[counter]
@@ -412,33 +402,18 @@ def get_profiles(all_frames, counter, order, poly_cos):
         mdl1 = mdl1+poly_cos[i]*((a*wavelengths)+b)**(i)
     mdl1 = mdl1*poly_cos[-1]
 
-    #masking based off residuals (needs to be redone for each frame as wavelength grid is different) -- NO - the same masking needs to be applied to each frame
-    #the mask therefore needs to be interpolated onto the new wavelength grid.
-
+    #masking based off residuals interpolated onto new wavelength grid
+    if len(frame_wavelengths)>1:
+        reference_wave = frame_wavelengths[sns==max(sns)][0]
+    else:
+        reference_wave = frame_wavelengths[0]
     mask_pos = np.ones(reference_wave.shape)
     mask_pos[mask_idx]=10000000000000000000
     f2 = interp1d(reference_wave, mask_pos, bounds_error = False, fill_value = np.nan)
     interp_mask_pos = f2(wavelengths)
     interp_mask_idx = tuple([interp_mask_pos>=10000000000000000000])
-    
 
     error[interp_mask_idx]=10000000000000000000
-    
-    # finding error for the continuuum fit
-    inds = np.random.randint(len(flat_samples), size=50)
-    conts = []
-    for ind in inds:
-        sample = flat_samples[ind]
-        mdl = model_func(sample, wavelengths)
-        #mdl = model_func(sample, x)
-        #mdl = mdl[idx]
-        mdl1_temp = 0
-        for i in np.arange(k_max, len(sample)-1):
-            mdl1_temp = mdl1_temp+sample[i]*((a*wavelengths)+b)**(i-k_max)
-        mdl1_temp = mdl1_temp*sample[-1]
-        conts.append(mdl1_temp)
-
-    continuum_error = np.std(np.array(conts), axis = 0)
 
     # corrrecting continuum
     error = (error/flux) + (continuum_error/mdl1)
@@ -521,7 +496,7 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
         line (str): Path to linelist. Takes VALD linelist in long or short format as input. Minimum line depth input into VALD must be less than 1/(3*SN) where SN is the highest signal-to-noise ratio of the spectra. 
         frame_sns (list): Average signal-to-noise ratio for each frame (used to calculate minimum line depth to consider from line list. 
         vgrid (array): Velocity grid for LSD profiles (in km/s).
-        all_frames (str or array, optional): Output array for resulting profiles. Only neccessary if looping ACID function over many wavelength regions or order (in the case of echelle spectra). General shape needs to be (no. of frames, no. of orders, 2, no. of velocity pixels). 
+        all_frames (str or array, optional): Output array for resulting profiles. Only neccessary if looping ACID function over many wavelength regions or order (in the case of echelle spectra). General shape needs to be (no. of frames, 1, 2, no. of velocity pixels). 
         poly_or (int, optional): Order of polynomial to fit as the continuum.
         pix_chunk (int, optional): Size of 'bad' regions in pixels. 'bad' areas are identified by the residuals between an inital model and the data. If a residual deviates by a specified percentage (dev_perv) for a specified number of pixels (pix_chunk) it is masked. The smaller the region the less aggresive the masking applied will be.
         dev_perc (int, optional): Allowed deviation percentage. 'bad' areas are identified by the residuals between an inital model and the data. If a residual deviates by a specified percentage (dev_perv) for a specified number of pixels (pix_chunk) it is masked. The smaller the deviation percentage the less aggresive the masking applied will be.
@@ -532,6 +507,9 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
     Returns:
         array: Resulting profiles and errors for spectra.
     """ 
+    print('Initialising...')
+
+    t0 = time.time()
 
     global velocities
     velocities = vgrid.copy()
@@ -550,8 +528,9 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
     frame_errors = np.array(input_spectral_errors)
     sns = np.array(frame_sns)
 
-    if all_frames == []:
-        all_frames = np.zeros((len(frames), 1, 2, len(velocities)))
+    if type(all_frames)!=np.ndarray:
+        if all_frames=='default':
+            all_frames = np.zeros((len(frames), 1, 2, len(velocities)))
 
     fw = frame_wavelengths.copy()
     f = frames.copy()
@@ -562,15 +541,20 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
         wavelengths, fluxes, flux_error_order, sn = combine_spec(fw, f, fe, s)
     else: wavelengths, fluxes, flux_error_order, sn = fw[0], f[0], fe[0], s[0]
 
-        ### getting the initial polynomial coefficents
+    ### getting the initial polynomial coefficents
     a = 2/(np.max(wavelengths)-np.min(wavelengths))
     b = 1 - a*np.max(wavelengths)
     poly_inputs, fluxes1, flux_error_order1, fit = continuumfit(fluxes,  (wavelengths*a)+b, flux_error_order, poly_ord)
 
+    # t2 = time.time()
+    # print('Set up before LSD %s'%(t2-t0))
     #### getting the initial profile
     global alpha
     velocities, profile, profile_errors, alpha, continuum_waves, continuum_flux, no_line= LSD.LSD(wavelengths, fluxes1, flux_error_order1, linelist, 'False', poly_ord, sn, 30, run_name, velocities)
 
+    # t3 = time.time()
+    # print('LSD run takes: %s'%(t3-t2))
+
     ## Setting the number of points in vgrid (k_max)
     global k_max
     k_max = len(profile)
@@ -590,6 +574,9 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
     
     yerr, model_inputs_resi, mask_idx = residual_mask(x, y, yerr, model_inputs, poly_ord, linelist, pix_chunk=pix_chunk, dev_perc=dev_perc, tell_lines = telluric_lines, n_sig=n_sig)
 
+    # t4 = time.time()
+    # print('residual masking takes: %s' %(t4-t3))
+
     ## setting number of walkers and their start values(pos)
     ndim = len(model_inputs)
     nwalkers= ndim*3
@@ -612,12 +599,17 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
     ## the number of steps is how long it runs for - if it doesn't look like it's settling at a value try increasing the number of steps
     steps_no = 8000
 
-    sampler = emcee.EnsembleSampler(nwalkers, ndim, log_probability, args=(x, y, yerr))
-    sampler.run_mcmc(pos, steps_no, progress=True)
+    t1 = time.time()
+    # print('MCMC set up takes: %s'%(t1-t4))
+    # print('Initialised in %ss'%round((t1-t0), 2))
+
+    print('Fitting the Continuum...')
+    # sampler = emcee.EnsembleSampler(nwalkers, ndim, log_probability, args=(x, y, yerr))
+    # sampler.run_mcmc(pos, steps_no, progress=True)
 
-    # with Pool() as pool:
-    #     sampler = emcee.EnsembleSampler(nwalkers, ndim, log_probability, args=(x, y, yerr), pool=pool)
-    #     sampler.run_mcmc(pos, steps_no, progress=True)
+    with Pool() as pool:
+        sampler = emcee.EnsembleSampler(nwalkers, ndim, log_probability, args=(x, y, yerr), pool=pool)
+        sampler.run_mcmc(pos, steps_no, progress=True)
 
     ## discarding all vales except the last 1000 steps.
     dis_no = int(np.floor(steps_no-1000))
@@ -648,7 +640,6 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
     profile = np.array(profile)
     profile_err = np.array(profile_err)
 
-
     fig_opt = 'n'
     if fig_opt =='y':
 
@@ -748,13 +739,34 @@ def ACID(input_wavelengths, input_spectra, input_spectral_errors, line, frame_sn
         ax0.legend()
         plt.savefig('figures/final_profile_%s'%(run_name))
 
-    # task_part = partial(get_profiles, all_frames)
-    # with mp.Pool(mp.cpu_count()) as pool:results=[pool.map(task_part, np.arange(len(frames)))]
-    # results = np.array(results[0])
-    # for i in range(len(frames)):
-    #     all_frames[i]=results[i][i]
-    for counter in range(len(frames)):
-        all_frames = get_profiles(all_frames, counter, order, poly_cos)  
+    print('Getting the final profiles...')
+
+    # finding error for the continuuum fit
+    inds = np.random.randint(len(flat_samples), size=50)
+    conts = []
+    for ind in inds:
+        sample = flat_samples[ind]
+        mdl = model_func(sample, wavelengths)
+        #mdl = model_func(sample, x)
+        #mdl = mdl[idx]
+        mdl1_temp = 0
+        for i in np.arange(k_max, len(sample)-1):
+            mdl1_temp = mdl1_temp+sample[i]*((a*wavelengths)+b)**(i-k_max)
+        mdl1_temp = mdl1_temp*sample[-1]
+        conts.append(mdl1_temp)
+
+    continuum_error = np.std(np.array(conts), axis = 0)
+
+    task_part = partial(get_profiles, all_frames, order, poly_cos, continuum_error)
+    if len(frames)>1:
+        with mp.Pool(mp.cpu_count()) as pool:
+            results=[pool.map(task_part, np.arange(len(frames)))]
+        results = np.array(results[0])
+        for i in range(len(frames)): 
+            all_frames[i]=results[i][i]
+        # for counter in range(len(frames)):
+        #     all_frames = get_profiles(all_frames, order, poly_cos, continuum_error, counter)  
+    else: all_frames = get_profiles(all_frames, order, poly_cos, continuum_error, 0)
 
     return all_frames
 
@@ -797,6 +809,7 @@ def ACID_HARPS(filelist, line, vgrid, poly_or=3, order_range=np.arange(10,70), s
     global frame_errors
     global sns
 
+    
     for order in order_range:
     
         print('Running for order %s/%s...'%(order-min(order_range)+1, max(order_range)-min(order_range)+1))

ACID_code/LSD_func_faster.py

@@ -3,12 +3,15 @@ from scipy import linalg
 from astropy.io import  fits
 import glob
 import matplotlib.pyplot as plt
-
+import time
 from scipy.signal import find_peaks
 from scipy.interpolate import interp1d,LSQUnivariateSpline
+import warnings
 
 def LSD(wavelengths, flux_obs, rms, linelist, adjust_continuum, poly_ord, sn, order, run_name, velocities):
 
+    # t0 = time.time()
+
     #idx = tuple([flux_obs>0])
     # in optical depth space
     rms = rms/flux_obs
@@ -20,49 +23,76 @@ def LSD(wavelengths, flux_obs, rms, linelist, adjust_continuum, poly_ord, sn, or
     linelist_expected = np.genfromtxt('%s'%linelist, skip_header=4, delimiter=',', usecols=(1,9))
     wavelengths_expected1 =np.array(linelist_expected[:,0])
     depths_expected1 = np.array(linelist_expected[:,1])
-    # print(len(depths_expected1))
 
     wavelength_min = np.min(wavelengths)
     wavelength_max = np.max(wavelengths)
 
-    wavelengths_expected=[]
-    depths_expected=[]
-    no_line =0
-    for some in range(0, len(wavelengths_expected1)):
-        line_min = 1/(3*sn)
-        if wavelengths_expected1[some]>=wavelength_min and wavelengths_expected1[some]<=wavelength_max and depths_expected1[some]>=line_min:
-            wavelengths_expected.append(wavelengths_expected1[some])
-            #depths_expected.append(depths_expected1[some]+random.uniform(-0.1, 0.1))
-            depths_expected.append(depths_expected1[some])
-            no_line+=1
-        else:
-            pass
-
-    depths_expected1 = np.array(depths_expected)
-    depths_expected = -np.log(1-depths_expected1)
+    idx = np.logical_and(wavelengths_expected1>=wavelength_min, wavelengths_expected1<=wavelength_max)
+    wavelengths_expected=wavelengths_expected1[idx]
+    depths_expected=depths_expected1[idx]
+
+    line_min = 1/(3*sn)
+    idx = (depths_expected>=line_min)
+    wavelengths_expected = wavelengths_expected[idx]
+    depths_expected = depths_expected[idx]
+    no_line = len(depths_expected)
+    
+    depths_expected = -np.log(1-depths_expected)
     
     blankwaves=wavelengths
     R_matrix=flux_obs
 
-    alpha=np.zeros((len(blankwaves), len(velocities)))
-
-    for j in range(0, len(blankwaves)):
-        for i in (range(0,len(wavelengths_expected))):
-            vdiff = ((blankwaves[j] - wavelengths_expected[i])*2.99792458e5)/wavelengths_expected[i]
-            if vdiff<=(np.max(velocities)+deltav) and vdiff>=(np.min(velocities)-deltav):
-                diff=blankwaves[j]-wavelengths_expected[i]
-                vel=2.99792458e5*(diff/wavelengths_expected[i])
-                for k in range(0, len(velocities)):
-                    x=(velocities[k]-vel)/deltav
-                    if -1.<x and x<0.:
-                        delta_x=(1+x)
-                        alpha[j, k] = alpha[j, k]+depths_expected[i]*delta_x
-                    elif 0.<=x and x<1.:
-                        delta_x=(1-x)
-                        alpha[j, k] = alpha[j, k]+depths_expected[i]*delta_x
-            else:
-                pass
-            
+    # t1 = time.time()
+    # print('Time is %s'%(t1-t0))
+    
+    # Calculate vdiff for all combinations of blankwaves and wavelengths_expected
+    vdiff = ((blankwaves[:, np.newaxis] - wavelengths_expected) * 2.99792458e5) / wavelengths_expected
+
+    # Create masks for vdiff that satisfy velocity range conditions
+    velocity_mask = np.logical_and(vdiff <= (np.max(velocities) + deltav), vdiff >= (np.min(velocities) - deltav))
+
+    # Find differences and velocities
+    diff = blankwaves[:, np.newaxis] - wavelengths_expected
+    vel = 2.99792458e5 * (diff / wavelengths_expected)
+
+    # Calculate x and delta_x for valid velocities
+    if len(wavelengths)<= 7000:
+        x = (vel[:, :, np.newaxis] - velocities) / deltav
+        alpha_mask_1 = np.logical_and(-1. < x, x < 0.)
+        alpha_mask_2 = np.logical_and(0. <= x, x < 1.)
+        delta_x_1 = 1 + x
+        delta_x_2 = 1 - x
+        delta_x_1[alpha_mask_1==False]=0
+        delta_x_2[alpha_mask_2==False]=0
+
+        # Update alpha array using calculated delta_x values
+        alpha = np.zeros((len(blankwaves), len(velocities)))
+        alpha += (depths_expected[:, np.newaxis] * delta_x_1).sum(axis=1)
+        alpha += (depths_expected[:, np.newaxis] * delta_x_2).sum(axis=1)
+    else:
+        warnings.warn('Large wavelength ranges give large computation time. Seperate wavelength range into smaller chunks for faster computation.', DeprecationWarning, stacklevel=2)
+        alpha=np.zeros((len(blankwaves), len(velocities)))
+
+        for j in range(0, len(blankwaves)):
+            for i in (range(0,len(wavelengths_expected))):
+                vdiff = ((blankwaves[j] - wavelengths_expected[i])*2.99792458e5)/wavelengths_expected[i]
+                if vdiff<=(np.max(velocities)+deltav) and vdiff>=(np.min(velocities)-deltav):
+                    diff=blankwaves[j]-wavelengths_expected[i]
+                    vel=2.99792458e5*(diff/wavelengths_expected[i])
+                    for k in range(0, len(velocities)):
+                        x=(velocities[k]-vel)/deltav
+                        if -1.<x and x<0.:
+                            delta_x=(1+x)
+                            alpha[j, k] = alpha[j, k]+depths_expected[i]*delta_x
+                        elif 0.<=x and x<1.:
+                            delta_x=(1-x)
+                            alpha[j, k] = alpha[j, k]+depths_expected[i]*delta_x
+                else:
+                    pass
+
+    # t2 = time.time()
+    # print('Alpha time: %s'%(t2-t1))
+    
     id_matrix=np.identity(len(flux_obs))
     S_matrix=(1/rms)*id_matrix
 
@@ -70,7 +100,7 @@ def LSD(wavelengths, flux_obs, rms, linelist, adjust_continuum, poly_ord, sn, or
     alpha_transpose=(np.transpose(alpha))
 
     RHS_1=np.dot(alpha_transpose, S_squared)
-    RHS_final=np.dot(RHS_1, R_matrix )
+    RHS_final=np.dot(RHS_1, R_matrix)
 
     LHS_preinvert=np.dot(RHS_1, alpha)
     LHS_prep=np.matrix(LHS_preinvert)
@@ -87,6 +117,9 @@ def LSD(wavelengths, flux_obs, rms, linelist, adjust_continuum, poly_ord, sn, or
     profile_errors_squared=np.diagonal(LHS_final)
     profile_errors=np.sqrt(profile_errors_squared)
 
+    # t3 = time.time()
+    # print('Matrix multiplication time: %s'%(t3-t2))
+
     return velocities, profile, profile_errors, alpha, wavelengths_expected, depths_expected1, no_line
 
 def get_wave(data,header):
@@ -219,24 +252,34 @@ def blaze_correct(file_type, spec_type, order, file, directory, masking, run_nam
         # wave=hdu[0].header['CRVAL1']+(hdu[0].header['CRPIX1']+np.arange(spec.shape[0]))*hdu[0].header['CDELT1']
         
         wave=hdu[0].header['CRVAL1']+(np.arange(spec.shape[0]))*hdu[0].header['CDELT1']
+        
+        where_are_zeros = (spec<=0)
+        spec[where_are_zeros] = 1000000000000
+        flux_error = np.sqrt(spec)
 
         # print(wave)
 
         if spec_type == 'order':
             wavelengths=[]
             fluxes=[]
+            errors = []
             for value in range(0, len(wave)):
                 l_wave=wave[value]
                 l_flux=spec[value]
+                l_error=flux_error[value]
                 if l_wave>=wavelength_min and l_wave<=wavelength_max:
                     wavelengths.append(l_wave)
                     fluxes.append(l_flux)
+                    errors.append(l_error)
             wavelengths = np.array(wavelengths)
             fluxes = np.array(fluxes)
+            errors = np.array(errors)
+
 
             if len(wavelengths)>5144:
                 wavelengths = wavelengths[:5144]
                 fluxes = fluxes[:5144]
+                flux_error = errors[:5144]
             # print(len(wavelengths))
             # print(np.max(wavelengths), np.min(wavelengths))
             # print(min_overlap)
@@ -258,12 +301,10 @@ def blaze_correct(file_type, spec_type, order, file, directory, masking, run_nam
             # if len(spec_check)>0:
             #     print('WARNING NEGATIVE/ZERO FLUX - corrected')
 
-            flux_error = np.sqrt(fluxes)
-            where_are_NaNs = np.isnan(flux_error)
-            flux_error[where_are_NaNs] = 1000000000000
-            where_are_zeros = np.where(fluxes == 0)[0]
-            flux_error[where_are_zeros] = 1000000000000
-
+            # where_are_zeros = (spec<=0)
+            # spec[where_are_zeros] = 1000000000000
+            # flux_error = np.sqrt(spec)
+            
             flux_error_order = flux_error
             masked_waves = []
             masked_waves = np.array(masked_waves)

ACID_code/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.0"
+__version__ = "0.1.0"

{ACID_code-0.0.0.dist-info → ACID_code-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ACID-code
-Version: 0.0.0
+Version: 0.1.0
 Summary: Returns line profiles from input spectra by fitting the stellar continuum and performing LSD
 License-File: LICENSE
 Requires-Dist: numpy
@@ -9,4 +9,6 @@ Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: astropy
 Requires-Dist: statistics
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: tqdm
 

ACID_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+ACID_code/ACID.py,sha256=EAD-HaAhD4QTJpgLhFI6lIJLPCD8d6irpgwcKhlvZGk,35438
+ACID_code/LSD_func_faster.py,sha256=N52i9bhhZTLb-yBL_Es9ADzgiy-adD2ZbkfTrN9noJA,44056
+ACID_code/__init__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+ACID_code-0.1.0.dist-info/LICENSE,sha256=L6dUgqjvHmRoobrBCPSHKC4UtRM5Ldp1DJBC4bnLk3w,1070
+ACID_code-0.1.0.dist-info/METADATA,sha256=sx8ZAIwoH87--HJHbQ4cdNUXxbKV5t9vxl4SuofLL88,368
+ACID_code-0.1.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+ACID_code-0.1.0.dist-info/top_level.txt,sha256=O4OaSabv1ebFYQmHgftr1PGAv6BvC2l81Y3HjgNehQI,10
+ACID_code-0.1.0.dist-info/RECORD,,