PycWB 0.30.0__tar.gz → 0.30.1__tar.gz

{pycwb-0.30.0 → pycwb-0.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycWB
-Version: 0.30.0
+Version: 0.30.1
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.30.0 → pycwb-0.30.1}/PycWB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycWB
-Version: 0.30.0
+Version: 0.30.1
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.30.0'
-__version_tuple__ = version_tuple = (0, 30, 0)
+__version__ = version = '0.30.1'
+__version_tuple__ = version_tuple = (0, 30, 1)
 
-__commit_id__ = commit_id = 'g93b86f797'
+__commit_id__ = commit_id = 'ge6efcc9ce'

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/constants/detectors.py

@@ -38,11 +38,29 @@ DETECTORS = {
         "elevation": 51.884,
         "x": {
             "alt": 0.00000000000,
-            "az": 0.33916285222
+            "az": 0.33916285222,
+            "midpoint": 1500.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 5.05155183261
+            "az": 5.05155183261,
+            "midpoint": 1500.00000000000
+        }
+    },
+    "I1": {
+        "name": "LIO_4k",
+        "lat": 0.24841853020,
+        "lon": 1.33401332494,
+        "elevation": 0.0,
+        "x": {
+            "alt": 0.00000000000,
+            "az": 1.57079637051,
+            "midpoint": 2000.00000000000
+        },
+        "y": {
+            "alt": 0.00000000000,
+            "az": 0.00000000000,
+            "midpoint": 2000.00000000000
         }
     },
     "G1": {
@@ -52,11 +70,13 @@ DETECTORS = {
         "elevation": 114.425,
         "x": {
             "alt": 0.00000000000,
-            "az": 1.19360100484
+            "az": 1.19360100484,
+            "midpoint": 300.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 5.83039279401
+            "az": 5.83039279401,
+            "midpoint": 300.00000000000
         }
     },
     "E1": {
@@ -66,11 +86,13 @@ DETECTORS = {
         "elevation": 51.884,
         "x": {
             "alt": 0.00000000000,
-            "az": 0.33916285222
+            "az": 0.33916285222,
+            "midpoint": 5000.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 5.57515060820
+            "az": 5.57515060820,
+            "midpoint": 5000.00000000000
         }
     },
     "E2": {
@@ -80,11 +102,13 @@ DETECTORS = {
         "elevation": 59.735,
         "x": {
             "alt": 0.00000000000,
-            "az": 4.52795305701
+            "az": 4.52795305701,
+            "midpoint": 5000.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 3.48075550581
+            "az": 3.48075550581,
+            "midpoint": 5000.00000000000
         }
     },
     "E3": {
@@ -94,11 +118,13 @@ DETECTORS = {
         "elevation": 59.727,
         "x": {
             "alt": 0.00000000000,
-            "az": 2.43355795462
+            "az": 2.43355795462,
+            "midpoint": 5000.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 1.38636040342
+            "az": 1.38636040342,
+            "midpoint": 5000.00000000000
         }
     },
     "E0": {
@@ -108,11 +134,13 @@ DETECTORS = {
         "elevation": 59.727,
         "x": {
             "alt": 0.00000000000,
-            "az": 0.00000000000
+            "az": 0.00000000000,
+            "midpoint": 0.00000000000
         },
         "y": {
             "alt": 0.00000000000,
-            "az": 0.00000000000
+            "az": 0.00000000000,
+            "midpoint": 0.00000000000
         }
     },
     "K1": {
@@ -122,11 +150,13 @@ DETECTORS = {
         "elevation": 414.181,
         "x": {
             "alt": 0.0031414,
-            "az": 1.054113
+            "az": 1.054113,
+            "midpoint": 1513.2535
         },
         "y": {
             "alt": -0.0036270,
-            "az": -0.5166798
+            "az": -0.5166798,
+            "midpoint": 1511.611
         }
     }
-}
+}

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/constants/user_parameters_schema.py

@@ -45,6 +45,11 @@ schema = {
             "default": False,
             "cwb": False
         },
+        "save_waveform_format": {
+            "enum": ["txt", "hdf"],
+            "description": "format to save waveform from triggers, options are: 'txt' and 'hdf'",
+            "default": "hdf"
+        },
         "plot_waveform": {
             "type": "boolean",
             "description": "plot waveform from triggers",
@@ -584,12 +589,12 @@ schema = {
         },
         "whiteWindow": {
             "type": "number",
-            "description": "[sec] time window dT. if = 0 - dT=T, where T is segment duration",
+            "description": "[sec] time window dT. if = 0 - dT=T, where T is segment duration. If whiteMethod='mesa', controls the MESA nRMS estimate (no values other than 60 have been tested in this context)",
             "default": 60.
         },
         "whiteStride": {
             "type": "number",
-            "description": "[sec] noise sampling time stride",
+            "description": "[sec] noise sampling time stride. If whiteMethod='mesa', controls the MESA nRMS estimate (no values other than 20 have been tested in this context)",
             "default": 20.
         },
         "mesaSolver": {
@@ -602,6 +607,21 @@ schema = {
             "description": "Maximum Autoregressive order for the Lenvinson Recursion", 
             "default": 800.
         },
+        "mesaHalfSeg": {
+            "type": "number", 
+            "description": "half - 1 size of the number of PSD over which the median over which the median is computed. If < 1, no median is applied", 
+            "default": 4
+        },
+        "mesaWindow": {
+            "type": "number", 
+            "description": "window length [sec] used to compute MESA PSD estimates", 
+            "default": 15 
+        },
+        "mesaStride": {
+            "type": "number", 
+            "description": "stride length [sec] between two consecutive MESA PSD estimates. Should be mesaWindow / 3", 
+            "default": 5
+        },
         "whiteMethod": {
             "type": "string",
             "description": "Sets what type of whitening has to be used. if 'wavelet' WDM time-frequency domain is applied. if 'mesa', it whitens with a PSD estimate given by mesa in the frequency domain. If 'mixed', the whitening is performed in time frequency domain but the nRMS is substitued with a MESA estimate for the coefficients", 

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/modules/cwb_conversions/series.py

@@ -166,7 +166,7 @@ def WSeries_to_matrix(w):
     :rtype: np.array
     """
     matrix = list()
-    for n in range(w.maxLayer()):
+    for n in range(w.maxLayer() + 1):
         a = ROOT.wavearray(np.double)()
         w.getLayer(a, n)
         matrix.append(np.asarray(a))

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/modules/data_conditioning/whitening_mesa.py

@@ -38,9 +38,9 @@ def whitening_mesa(config, h):
     wdm_white = WDM(layers_white, layers_white, config.WDM_beta_order, config.WDM_precision)
     wdmFlen = wdm_white.m_H / config.rateANA
     
-    if config.whiteStride != config.whiteWindow / 3: 
-        logger.warning('Value of whiteStride in config must be one third of whiteWindow. It will be changed in the analysis')
-        config.whiteStride = config.whiteWindow / 3 
+    if config.mesaStride != config.mesaWindow / 3: 
+        logger.warning('Value of mesa Stide in config must be one third of mesa Window. It will be changed in the analysis')
+        config.mesaStride = config.mesaWindow / 3 
     #Sampling variables 
     sampling_rate = config.inRate / (2 ** config.levelR)
     Ny = .5 * sampling_rate     #The Nyquist frequency 
@@ -62,8 +62,8 @@ def whitening_mesa(config, h):
     
     #Initialise whitening
     M = MESA() 
-    stride = int(config.whiteStride * sampling_rate)
-    window = int(config.whiteWindow * sampling_rate)
+    stride = int(config.mesaStride * sampling_rate)
+    window = int(config.mesaWindow * sampling_rate)
      
     psds = [] 
     h_white = h.copy() 
@@ -74,9 +74,15 @@ def whitening_mesa(config, h):
         M.solve(h[start:start+ window], method = config.mesaSolver, m = config.mesaOrder)
         f, psd = M.spectrum(1 / sampling_rate) 
         psds.append(psd) 
-    
+
+    #Smooth the PSDs estimates with a rolling median filter
+    if config.mesaHalfSeg > 0: 
+        logger.info(f"Smoothing PSDs estimates with rolling median filter over {config.mesaHalfSeg * 2 + 1} segments")
+        psds = rolling_median(np.array(psds), half_size = config.mesaHalfSeg)
+
     #reindex psds to exclude possibly-glitch-contaminated estimates 
     if config.mesaReindex: 
+        logger.warning("Reindexing PSDs estimates with Isolation Forest to exclude possible glitch contamination. To disable set mesaReindex to False in config file")
         psds = reindex_psds(np.array(psds), f)
 
     W = planck_taper_window(window) 
@@ -98,7 +104,7 @@ def whitening_mesa(config, h):
             h_white[start + stride:stop-stride] = h_w[stride:-stride]
     del(h_tmp) 
     del(h_w) 
-    edge = int(config.segEdge * sampling_rate)
+
     #Initialize TF map 
     tf_map = ROOT.WSeries(np.double)(convert_to_wavearray(h[:stop]), wdm_white.wavelet)
     tf_map.Forward()
@@ -114,31 +120,62 @@ def whitening_mesa(config, h):
     #Compute effective whitening filter 
     nRMS_matrix = WSeries_to_matrix(tf_map) / WSeries_to_matrix(tf_map_white)
     
-
-    #Compute the nRMS taking the median over 20 second segments and convert to array 
+    #Compute the nRMS taking the median over "whiteStride" seconds segments and convert to array 
     data_per_batch = int(config.whiteStride // wdm_dt)
-    nRMS_reshaped = nRMS_matrix.reshape(int(Ny / wdm_df),-1,data_per_batch) 
-    #set nRMS = 1 for f <= 16 
+    nRMS_reshaped = nRMS_matrix.reshape(int(Ny / wdm_df)+1,-1,data_per_batch) 
     nRMS_reshaped[:int(16 / wdm_df) + 1] = 1     
+    
     #Compute the nRMS as the median over the segments ignoring nans if present
     nRMS = np.sqrt(np.nanmedian(nRMS_reshaped ** 2, axis = 2))
-
-    #add 1 as last frequency bin for compatibility 
-    n_segments = nRMS_reshaped.shape[1]
-    nRMS = np.vstack((nRMS,np.ones((1,n_segments)))).reshape(-1, order = 'F')  
-    nRMS = generate_nrms_wseries(config, h, nRMS)
-
-    #nRMS = _convert_numpy_nrms_to_wseries(nRMS, h.start_time, sampling_rate, n_segments,  wdm_white.wavelet)
+    nRMS = generate_nrms_wseries(config, h, nRMS.reshape(-1, order = 'F'))
+    
+    #Convert to tf map types
     tf_map_whitened = ROOT.WSeries(np.double)(convert_to_wavearray(h_white), wdm_white.wavelet)
     tf_map_whitened.w_mode = 1   #Change w_mode to 1 for compatibility with "Network.cc" 
-
     tf_map_whitened = convert_wseries_to_time_frequency_series(tf_map_whitened)
     n_rms = convert_wseries_to_time_frequency_series(nRMS)
-
     
     return tf_map_whitened, n_rms
 
 
+def rolling_median(psds, half_size): 
+    """ 
+    Smooths the PSDs estimates with a rolling median filter 
+
+    Parameters: 
+    ----------
+    psds:   np.ndarray (N_segments, N_frequencies)      
+            array containing all the PSDs estimates 
+    half_size: int, optional
+            Half size of the rolling median window. The number of segments is The default is 2 * half_size + 1. 
+            Default value is 4 
+    """ 
+
+    out = np.empty_like(psds)
+    N = psds.shape[0]
+    
+    for i in range(N):
+        #Define left and right edges of the rolling median window
+        left = i - half_size
+        right = i + half_size + 1  
+
+        # If we run off the left edge, extend to the right to compensate
+        if left < 0:
+            deficit = -left
+            left = 0
+            right = min(N, right + deficit)
+
+        # If we run off the right edge, extend to the left to compensate
+        if right > N:
+            deficit = right - N
+            right = N
+            left = max(0, left - deficit)
+
+        out[i] = np.median(psds[int(left):int(right)], axis=0)
+
+    return out
+
+
 def reindex_psds(psds, f): 
     """ 
     Uses Isolation Forest to exclude PSDs estimates with a too large deviation from the median to exclude glitch contamination 
@@ -160,7 +197,7 @@ def reindex_psds(psds, f):
     dist_lf = np.mean((np.log(psds[:,mask_lf] / psd_median[mask_lf])) ** 2, axis = 1) ** .5
     dist_hf = np.mean((np.log(psds[:,mask_hf] / psd_median[mask_hf])) ** 2, axis = 1) ** .5
     dist = np.stack([dist_lf, dist_hf], axis = 1)
-    predictions = IsolationForest(n_estimators = 100).fit_predict(dist)
+    predictions = IsolationForest(n_estimators = 100, contamination = .15).fit_predict(dist)
     
     #Remove outliers if found below the median  
     median_lf, median_hf = np.median([dist_lf,dist_hf], axis = 1)
@@ -173,7 +210,7 @@ def reindex_psds(psds, f):
     for idx in outliers_idx: 
         new_idx = inliers_idx[np.argmin(np.abs(inliers_idx-idx))]
         psds[idx] = psds[new_idx]
-        logger.info(f"Subsituting PSD {idx} with PSD {new_idx}")
+    logger.info(f"Reindexed {len(outliers_idx)} PSDs estimates out of {psds.shape[0]} total segments")
 
     return psds
 
@@ -209,7 +246,9 @@ def generate_nrms_wseries(config, data, nrms):
     tf_map.Forward()
     tf_map.setlow(config.fLow)
     tf_map.sethigh(config.fHigh)
-    nRMS = tf_map.white(config.whiteWindow, 0, config.segEdge,  config.whiteStride)
+    if config.whiteWindow != 60 or config.whiteStride != 20:
+        logger.warning(f"whiteWindow = {config.whiteWindow} and whiteStride = {config.whiteStride} in config are different from default values (60,20). This may lead to unexpected results in the whitening nRMS generation.")
+    nRMS = tf_map.white(config.whiteWindow, 0, config.segEdge, config.whiteStride)
     nRMS.bandpass(16., 0., 1)
     
     #Substitute the cWB nRMS with the MESA nRMS 

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/workflow/subflow/postprocess_and_plots.py

@@ -57,11 +57,11 @@ def reconstruct_waveforms_flow(trigger_folder: str, config: Config, ifos: List[s
 
         for i, ts in enumerate(reconstructed_waves):
             logger.info(f"Saving reconstructed waveform for {ifos[i]}")
-            ts.save(f"{trigger_folder}/reconstructed_waveform_{ifos[i]}.txt")
+            ts.save(f"{trigger_folder}/reconstructed_waveform_{ifos[i]}.{config.save_waveform_format}")
 
         for i, ts in enumerate(reconstructed_waves_whiten):
             logger.info(f"Saving reconstructed waveform for {ifos[i]} (whitened)")
-            ts.save(f"{trigger_folder}/reconstructed_waveform_{ifos[i]}_whitened.txt")
+            ts.save(f"{trigger_folder}/reconstructed_waveform_{ifos[i]}_whitened.{config.save_waveform_format}")
 
         # for i, (hp, hc) in enumerate(zip(reconstructed_waves_whiten_00, reconstructed_waves_whiten_90)):
         #     # save strain = hp + 1j hc
@@ -103,7 +103,7 @@ def reconstruct_waveforms_flow(trigger_folder: str, config: Config, ifos: List[s
             if save_injection:
                 for i, strain in enumerate(strains):
                     logger.info(f"Saving injected strain for {ifos[i]}")
-                    strain.save(f"{trigger_folder}/injected_strain_{ifos[i]}.txt")
+                    strain.save(f"{trigger_folder}/injected_strain_{ifos[i]}.{config.save_waveform_format}")
 
             if plot_injection:
                 from matplotlib import pyplot as plt

{pycwb-0.30.0 → pycwb-0.30.1}/pycwb/workflow/subflow/process_job_segment.py

@@ -122,6 +122,7 @@ def process_job_segment(working_dir: str, config: Config, job_seg: WaveSegment,
                 # associate the injections if there are any
                 if sub_job_seg.injections:
                     for injection in sub_job_seg.injections:
+                        # FIXME: for overlap signal, this won't work
                         if event.start[0] - 0.1 < injection['gps_time'] < event.stop[0] + 0.1:
                             event.injection = injection
             logger.info("Memory usage: %f.2 MB", psutil.Process().memory_info().rss / 1024 / 1024)