pyhough 0.0.1__tar.gz

pyhough-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyhough-0.0.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: pyhough
+Version: 0.0.1
+Summary: Package to compute the Frequency-Hough Transform to search for continuous gravitational waves in LIGO, Virgo and KAGRA data
+Project-URL: Homepage, https://github.com/andrew-l-miller/pyhough
+Project-URL: Issues, https://github.com/andrew-l-miller/pyhough/issues
+Author-email: "Andrew L. Miller" <andrew.miller.ligo@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pyhough Package
+
+This package provides codes to perform the frequency-Hough transform to search for continuous gravitational waves from asymetrically rotating neutron stars.
+
+In the package, which builds off of spectrograms created by Pyfstat, one can create a time/frequency peakmap, doppler correct it, and perform the Hough Transform.
+
+The Hough Transform can be applied to either the spectrogrma directly or the peakmap.
+

pyhough-0.0.1/README.md

@@ -0,0 +1,8 @@
+# pyhough Package
+
+This package provides codes to perform the frequency-Hough transform to search for continuous gravitational waves from asymetrically rotating neutron stars.
+
+In the package, which builds off of spectrograms created by Pyfstat, one can create a time/frequency peakmap, doppler correct it, and perform the Hough Transform.
+
+The Hough Transform can be applied to either the spectrogrma directly or the peakmap.
+

pyhough-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling","numpy","pyfstat","matplotlib"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyhough"
+version = "0.0.1"
+authors = [
+  { name="Andrew L. Miller", email="andrew.miller.ligo@gmail.com" },
+]
+description = "Package to compute the Frequency-Hough Transform to search for continuous gravitational waves in LIGO, Virgo and KAGRA data"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/andrew-l-miller/pyhough"
+Issues = "https://github.com/andrew-l-miller/pyhough/issues"

pyhough-0.0.1/src/pyhough/hm.py

@@ -0,0 +1,79 @@
+import numpy as np
+from pm import *
+
+def hfdf_hough_spectrogram(times,freqs,power,Tsft,sdgrid,threshold,vec_n,vels,ref_perc_time):
+#### times: unique times array
+#### freqs: unique freqs array
+#### power: spectrogram of size len(freqs) x len(times)
+    inif = np.min(freqs)
+    finf = np.max(freqs)
+    df = 1/Tsft
+    Nsds = len(sdgrid)
+    Ntts = len(times)
+
+    Nf0s = int(np.ceil((finf-inif)/df))
+
+    binh_df0 = np.zeros((Nsds,Nf0s))
+    t0 = np.percentile(times,ref_perc_time)
+
+    times = times - t0
+    for t in range(Ntts):
+        inds_above_thr = np.array(select_local_max(power[:,t],threshold))
+        if inds_above_thr.shape[0] == 0:
+            continue
+        
+        freqs_peaks = freqs[inds_above_thr]
+        freqs_dopp_corr = remove_doppler(freqs_peaks,vec_n,vels[:,t])
+        these_fs = ( freqs_dopp_corr - inif ) / df ;
+        tt_df = times[t] / df
+        for k in range(Nsds):
+            td = sdgrid[k] * tt_df
+            inds = np.round(these_fs - td).astype(int) ### f = f0 + fdot(t-t0) solve for f0, f0 = f - fdot(t-t0)
+            ind_of_inds = np.argwhere(inds>=0);
+            a = inds[ind_of_inds];
+            log_inds = a <= Nf0s-1;
+            a = a[log_inds];
+            binh_df0[k,a] = binh_df0[k,a] + 1
+    
+    return binh_df0
+
+
+def hfdf_hough(times,peak_freqs,Tsft,sdgrid,ref_perc_time):
+
+    inif = np.min(peak_freqs)
+    finf = np.max(peak_freqs)
+    df = 1/Tsft
+    Nsds = len(sdgrid)
+    Nf0s = int(np.ceil((finf-inif)/df))
+
+    binh_df0 = np.zeros((Nsds,Nf0s))
+    t0 = np.percentile(times,ref_perc_time)
+
+    ii0 = 0
+    ii = np.squeeze(np.argwhere(np.diff(times)))
+    times = times - t0
+    Ntts = len(ii)
+    for t in range(Ntts):
+        these_fs = ( peak_freqs[ii0:ii[t]+1] - inif ) / df 
+        tt_df = times[ii0] / df
+        for k in range(Nsds):
+            td = sdgrid[k] * tt_df
+            inds = np.round(these_fs - td).astype(int) ### f = f0 + fdot(t-t0) solve for f0, f0 = f - fdot(t-t0)
+            ind_of_inds = np.argwhere(inds>=0);
+            a = inds[ind_of_inds];
+            log_inds = a <= Nf0s-1;
+            a = a[log_inds];
+            binh_df0[k,a] = binh_df0[k,a] + 1
+            
+            
+        ii0 = ii[t]+1
+    return binh_df0
+
+def make_sd_grid(sig_fdot,dsd):
+    min_fdot_search = sig_fdot * 10
+    max_fdot_search = np.abs(sig_fdot * 10)
+    if min_fdot_search == 0:
+        min_fdot_search = -10 * dsd
+        max_fdot_search = 10 * dsd
+    sdgrid = np.arange(min_fdot_search,max_fdot_search,dsd)
+    return sdgrid

pyhough-0.0.1/src/pyhough/pm.py

@@ -0,0 +1,167 @@
+import numpy as np
+import pyfstat
+import matplotlib.pyplot as plt
+
+def get_detector_velocities(data):
+    states = pyfstat.DetectorStates().get_multi_detector_states_from_sfts(data.sftfilepath, central_frequency=data.F0, time_offset=0)
+    ts = np.array([data.tGPS.gpsSeconds for data in states.data[0].data])
+    velocities = np.vstack([data.vDetector for data in states.data[0].data]).T
+    return ts, velocities
+    
+    
+def astro2rect(a, icrad=0):
+    # Conversion from astronomical to rectangular coordinates
+    # position = [signal_parameters["Alpha"], signal_parameters["Delta"]]
+    # r = astro2rect(position,1) #icrad = 1: inputs are in rads; 0: inputs degs
+
+    if len(a) == 2:
+        a = np.append(a, 1)
+
+    if icrad == 0:
+        deg2rad = np.pi / 180
+        a[0] = a[0] * deg2rad
+        a[1] = a[1] * deg2rad
+
+    r = np.zeros(3)
+    r[0] = np.cos(a[0]) * np.cos(a[1]) * a[2]
+    r[1] = np.sin(a[0]) * np.cos(a[1]) * a[2]
+    r[2] = np.sin(a[1]) * a[2]
+
+    return r
+    
+    
+def remove_doppler(freqs,vec_n,velocities):
+
+    freqs_dopp_corr = freqs / (1 + np.dot(vec_n, velocities))
+    
+    return freqs_dopp_corr
+
+def python_plot_triplets(x,y,z,marker,label='',flag_logx=0,flag_logy=0,flag_log_cb=0,colorm='inferno'):
+
+    if flag_log_cb==1:
+        z=np.log10(z);
+    
+    #cmap=plt.get_cmap('inferno')
+    cmap=plt.get_cmap(colorm)
+    nc=cmap.N
+    mi=np.min(z);
+    ma=np.max(z);
+    mami=ma-mi;
+    zz=np.floor(nc*0.9999*(z-mi)/mami+1);
+
+    fig,ax=plt.subplots()
+
+    for i in range(nc):
+        col=cmap(i)
+#         if flag_logx==1 & flag_logy!=1:
+#             plt.semilogx(x[zz==i],y[zz==i],marker,markerfacecolor=col,markeredgecolor=col)
+#         elif flag_logy==1 & flag_logx!=1:
+#             plt.semilogy(x[zz==i],y[zz==i],marker,markerfacecolor=col,markeredgecolor=col)
+#         elif flag_logy==1 &flag_logx==1:
+#             plt.loglog(x[zz==i],y[zz==i],marker,markerfacecolor=col,markeredgecolor=col)
+#         else:
+        #cmaplist = [cmap(i) for i in range(cmap.N)]
+        plt.plot(x[zz==i],y[zz==i],marker,markerfacecolor=col,markeredgecolor=col)
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=mi, vmax=ma))
+    plt.colorbar(sm,label=label)
+    #plt.clim(mi, ma)
+    plt.grid(True)
+
+    return fig,ax
+
+def make_peakmap_from_spectrogram(alltimes,freqs,normalized_power,threshold=3):
+    Ntts = len(alltimes)
+    freqs_new = []
+    times_new = []
+    powss_new = []
+    index = [0]
+    num_peaks = 0
+    for t in range(Ntts):
+        inds_above_thr = np.array(select_local_max(normalized_power[:,t],threshold))
+        num_peaks = num_peaks + len(inds_above_thr)
+        index.extend([num_peaks])
+        if inds_above_thr.shape[0] == 0:
+            continue
+
+        freqs_peaks = freqs[inds_above_thr]        
+        freqs_new.extend(freqs_peaks)
+        times_new.extend(alltimes[t] * np.ones((len(freqs_peaks),1)))
+        powss_new.extend(normalized_power[inds_above_thr,t])
+        
+
+    times_new = np.squeeze(times_new)
+    freqs_new = np.squeeze(freqs_new)
+    powss_new = np.squeeze(powss_new)
+    
+    return times_new,freqs_new,powss_new,index
+
+def remove_doppler_from_peakmap(times_new,freqs_new,index,vec_n,vs,Nts):
+    freqs_undop = []
+    for t in range(Nts):
+        if t == Nts:
+            freqs_one_time = freqs_new[index[t]:]
+        else:
+            freqs_one_time = freqs_new[index[t]:index[t+1]]
+            
+        freqs_nodop = remove_doppler(freqs_one_time,vec_n,vs[:,t])
+        freqs_undop.extend(freqs_nodop)
+    
+    return freqs_undop
+
+
+def select_local_max(pows,threshold):
+
+    peaks_index = list()
+    for eqpow in range(1,len(pows)-1):
+        if pows[eqpow]>threshold:
+            if pows[eqpow]>pows[eqpow+1]:
+                if pows[eqpow]>pows[eqpow-1]:
+                    peaks_index.append(eqpow)
+    return peaks_index
+
+def remove_doppler_from_spectrogram_and_local_max_thresh(alltimes,freqs,normalized_power,vec_n,vs,threshold=3):
+#     alltimes = times["H1"]
+#     position = [signal_parameters["Alpha"], signal_parameters["Delta"]]
+#     vec_n = astro2rect(position,1)
+#     ts,vs = get_detector_velocities(data)
+    Ntts = len(alltimes)
+    freqs_new = []
+    times_new = []
+    powss_new = []
+    for t in range(Ntts):
+        inds_above_thr = np.array(select_local_max(normalized_power[:,t],threshold))
+        if inds_above_thr.shape[0] == 0:
+            continue
+        freqs_peaks = freqs[inds_above_thr]
+        freqs_dopp = remove_doppler(freqs_peaks,vec_n,vs[:,t])
+        freqs_new.extend(freqs_dopp)
+        times_new.extend(alltimes[t] * np.ones((len(freqs_dopp),1)))
+        powss_new.extend(normalized_power[inds_above_thr,t])
+
+
+
+    times_new = np.squeeze(times_new)
+    freqs_new = np.squeeze(freqs_new)
+    powss_new = np.squeeze(powss_new)
+    
+    return times_new,freqs_new,powss_new
+    
+
+def flatten_spectrogram(alltimes,freqs,normalized_power):
+    Ntts = len(alltimes)
+    freqs_flat = []
+    times_flat = []
+    powss_flat = []
+    index = [0]
+    num_peaks = 0
+    for t in range(Ntts):       
+        freqs_flat.extend(freqs)
+        times_flat.extend(alltimes[t] * np.ones((len(freqs),1)))
+        powss_flat.extend(normalized_power[:,t])
+        
+
+    times_flat = np.squeeze(times_flat)
+    freqs_flat = np.squeeze(freqs_flat)
+    powss_flat = np.squeeze(powss_flat)
+    
+    return times_flat,freqs_flat,powss_flat