PycWB 0.23.2__tar.gz → 0.24.0__tar.gz

{pycwb-0.23.2 → pycwb-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.23.2
+Version: 0.24.0
 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.23.2 → pycwb-0.24.0}/PycWB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.23.2
+Version: 0.24.0
 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.23.2 → pycwb-0.24.0}/PycWB.egg-info/SOURCES.txt

@@ -274,6 +274,10 @@ pycwb/modules/data_conditioning/regression.py
 pycwb/modules/data_conditioning/whitening.py
 pycwb/modules/energy_threshold/__init__.py
 pycwb/modules/energy_threshold/threshold.py
+pycwb/modules/gracedb/__init__.py
+pycwb/modules/gracedb/gracedb.py
+pycwb/modules/gracedb/module.yaml
+pycwb/modules/gracedb/test_gracedb.py
 pycwb/modules/job_segment/__init__.py
 pycwb/modules/job_segment/dq_segment.py
 pycwb/modules/job_segment/frame.py
@@ -281,6 +285,7 @@ pycwb/modules/job_segment/job_segment.py
 pycwb/modules/job_segment/module.yaml
 pycwb/modules/job_segment/plots.py
 pycwb/modules/job_segment/super_lag.py
+pycwb/modules/job_segment/test_job_segment.py
 pycwb/modules/likelihood/__init__.py
 pycwb/modules/likelihood/likelihood.py
 pycwb/modules/likelihood/module.yaml

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.23.2'
-__version_tuple__ = version_tuple = (0, 23, 2)
+__version__ = version = '0.24.0'
+__version_tuple__ = version_tuple = (0, 24, 0)

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/constants/user_parameters_schema.py

@@ -99,6 +99,46 @@ schema = {
             "default": {},
             "cwb": False
         },
+        "gps_start": {
+            "type": "number",
+            "description": "start gps time, used together with gps_end for generating job segments",
+            "cwb": False
+        },
+        "gps_end": {
+            "type": "number",
+            "description": "end gps time, used together with gps_start for generating job segments",
+            "cwb": False
+        },
+        "gps_center": {
+            "type": "number",
+            "description": "center gps time, used together with time_left and time_right for generating job segments",
+            "cwb": False
+        },
+        "time_left": {
+            "type": "number",
+            "description": "left time offset from gps_center, used together with gps_center and time_right for generating job segments",
+            "cwb": False
+        },
+        "time_right": {
+            "type": "number",
+            "description": "right time offset from gps_center, used together with gps_center and time_left for generating job segments",
+            "cwb": False
+        },
+        "superevent": {
+            "type": "string",
+            "description": "superevent name, used together with time_left and time_right for generating job segments",
+            "cwb": False
+        },
+        "gwdatafind": {
+            "type": "object",
+            "description": "If the gwdatafind is set, the framefiles can be pulled from the LIGO data server, "
+                           "the support keys are: site, frametype, host. Example: ",
+                           "     site: ['L','H']"
+                           "     frametype: ['L1_HOFT_C00','H1_HOFT_C00']"
+                           "     host: 'datafind.ldas.cit:80'"
+            "default": {},
+            "cwb": False
+        },
         "WDM_beta_order": {
             "type": "integer",
             "description": "WDM default parameters: beta function order for Meyer",

pycwb-0.24.0/pycwb/modules/gracedb/__init__.py

@@ -0,0 +1 @@
+from .gracedb import *

pycwb-0.24.0/pycwb/modules/gracedb/gracedb.py

@@ -0,0 +1,40 @@
+from ligo.gracedb.rest import GraceDb
+from ligo.gracedb.exceptions import HTTPError
+
+
+def get_superevent(event_name):
+    """
+    Get the super event for a given event name.
+
+    :param event_name: The name of the event.
+    :type event_name: str
+    :return: The super event.
+    :rtype: dict
+    """
+    client = GraceDb()
+    try:
+        response = client.superevent(event_name).json()
+    except HTTPError as e:
+        if e.response.status_code == 404:
+            print('No super event found for event {}'.format(event_name))
+            return None
+        else:
+            raise
+
+    return response
+
+
+def get_superevent_t0(event_name):
+    """
+    Get the GPS time of the super event for a given event name.
+
+    :param event_name: The name of the event.
+    :type event_name: str
+    :return: The GPS time of the super event.
+    :rtype: float
+    """
+    super_event = get_superevent(event_name)
+    if super_event is None:
+        return None
+
+    return super_event['t_0']

pycwb-0.24.0/pycwb/modules/gracedb/module.yaml

@@ -0,0 +1,4 @@
+name: gracedb
+author: pycWB
+description: A interface for the LIGO/Virgo GraceDB database
+dependencies: ["ligo-proxy-utils", "ligo-gracedb"]

pycwb-0.24.0/pycwb/modules/gracedb/test_gracedb.py

@@ -0,0 +1,27 @@
+import unittest
+from .gracedb import get_superevent_t0, get_superevent
+
+class TestGraceDB(unittest.TestCase):
+
+    def test_get_superevent_t0(self):
+        event_name = 'S241011k'
+        t0 = get_superevent_t0(event_name)
+        self.assertAlmostEqual(t0, 1412725132.96, places=1)
+
+    def test_get_superevent_t0_no_event(self):
+        event_name = 'S000000a'
+        t0 = get_superevent_t0(event_name)
+        self.assertIsNone(t0)
+
+    def test_get_superevent(self):
+        event_name = 'S241011k'
+        super_event = get_superevent(event_name)
+        self.assertEqual(super_event['superevent_id'], event_name)
+
+    def test_get_superevent_no_event(self):
+        event_name = 'S000000a'
+        super_event = get_superevent(event_name)
+        self.assertIsNone(super_event)
+
+if __name__ == '__main__':
+    unittest.main()

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/modules/job_segment/dq_segment.py

@@ -6,7 +6,7 @@ from pycwb.types.job import WaveSegment
 logger = logging.getLogger(__name__)
 
 
-def read_seg_list(dq_file_list, dq_cat):
+def read_seg_list(dq_file_list=None, dq_cat='CWB_CAT1', periods=None):
     """Load the files contains segment list from the data quality files below the data quality category (dq_file.load_file)).
     Then merge the segment list (merge_seg_list) and return the merged segment list.
 
@@ -14,14 +14,22 @@ def read_seg_list(dq_file_list, dq_cat):
     :type dq_file_list: list[DQFile]
     :param dq_cat: The data quality category.
     :type dq_cat: str
+    :param periods: Given start and stop periods.
+    :type periods: tuple[list[int], list[int]]
     :return: A list of segments.
     :rtype: list[WaveSegment]
     """
     seg_list = []
-    for dq_file in dq_file_list:
-        if dq_file.dq_cat <= dq_cat:
-            logger.info(f"Loading data quality file {dq_file.file}")
-            seg_list.append(dq_file.get_periods())
+    if dq_file_list is None or len(dq_file_list) == 0:
+        seg_list.append(([0], [np.inf]))
+    else:
+        for dq_file in dq_file_list:
+            if dq_file.dq_cat <= dq_cat:
+                logger.info(f"Loading data quality file {dq_file.file}")
+                seg_list.append(dq_file.get_periods())
+
+    if periods is not None:
+        seg_list.append(periods)
 
     if len(seg_list) == 0:
         logger.error("No CWB_CAT=%s files in the list", dq_cat)
@@ -93,7 +101,7 @@ def get_seg_list(ifo, dq_list, seg_len, seg_mls, seg_edge):
     return []
 
 
-def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge):
+def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge, sample_rate):
     """
     Build the job segment list.
 
@@ -108,6 +116,8 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge):
     output segA : xxx---------xxx \n
     output segB :             xxx----------xxx \n
 
+    :param ifos:  list of interferometers
+    :type ifos:  list[str]
     :param dq_list:  number of detectors
     :type dq_list:  list[DQFile]
     :param seg_len:  Segment length [sec]
@@ -116,6 +126,8 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge):
     :type seg_mls:  int
     :param seg_edge:  wavelet boundary offset [sec]
     :type seg_edge:  int
+    :param sample_rate:  sample rate [Hz]
+    :type sample_rate:  int
     :return:  Return the job segment list
     :rtype:  list[WaveSegment]
     """
@@ -141,7 +153,8 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge):
                 lostlivetime += length
                 continue
             seg_index += 1
-            job_list.append(WaveSegment(seg_index, ifos, start, stop))
+            job_list.append(WaveSegment(seg_index, ifos, start, stop,
+                                        seg_edge=seg_edge, sample_rate=sample_rate))
             continue
         if n == 1:
             if length > seg_len:
@@ -149,32 +162,40 @@ def get_job_list(ifos, dq_list, seg_len, seg_mls, seg_edge):
                 half = int(remainder / 2)
                 if half >= seg_mls:
                     seg_index += 1
-                    job_list.append(WaveSegment(seg_index, ifos, start, start + half))
+                    job_list.append(WaveSegment(seg_index, ifos, start, start + half,
+                                                seg_edge=seg_edge, sample_rate=sample_rate))
 
                     seg_index += 1
-                    job_list.append(WaveSegment(seg_index, ifos, start + half, stop))
+                    job_list.append(WaveSegment(seg_index, ifos, start + half, stop,
+                                                seg_edge=seg_edge, sample_rate=sample_rate))
                 else:
                     seg_index += 1
-                    job_list.append(WaveSegment(seg_index, ifos, start, start + seg_len))
+                    job_list.append(WaveSegment(seg_index, ifos, start, start + seg_len,
+                                                seg_edge=seg_edge, sample_rate=sample_rate))
             else:
                 seg_index += 1
-                job_list.append(WaveSegment(i, ifos, start, stop))
+                job_list.append(WaveSegment(i, ifos, start, stop,
+                                            seg_edge=seg_edge, sample_rate=sample_rate))
             continue
 
         for j in range(n - 1):
             seg_index += 1
-            job_list.append(WaveSegment(seg_index, ifos, seg_len * j + start, seg_len * j + start + seg_len))
+            job_list.append(WaveSegment(seg_index, ifos, seg_len * j + start, seg_len * j + start + seg_len,
+                                        seg_edge=seg_edge, sample_rate=sample_rate))
 
         remainder = stop - job_list[-1].end_time
         half = int(remainder / 2)
         if half >= seg_mls:
             seg_index += 1
-            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + half))
+            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + half,
+                                        seg_edge=seg_edge, sample_rate=sample_rate))
             seg_index += 1
-            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, stop))
+            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, stop,
+                                        seg_edge=seg_edge, sample_rate=sample_rate))
         else:
             seg_index += 1
-            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + seg_len))
+            job_list.append(WaveSegment(seg_index, ifos, job_list[-1].end_time, job_list[-1].end_time + seg_len,
+                                        seg_edge=seg_edge, sample_rate=sample_rate))
 
     logger.info('lost livetime after building of the standard job list = %d sec' % lostlivetime)
 

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/modules/job_segment/frame.py

@@ -65,9 +65,9 @@ def select_frame_list(frame_list, start, stop, seg_edge):
     :param frame_list: list of frame metadata
     :type frame_list: list[FrameFile]
     :param start: start time of the segment
-    :type start: int
+    :type start: int or float
     :param stop: stop time of the segment
-    :type stop: int
+    :type stop: int or float
     :param seg_edge: buffer of the segment
     :type seg_edge: int or float
     :return: list of frame
@@ -81,3 +81,46 @@ def select_frame_list(frame_list, start, stop, seg_edge):
     return frame_list
 
 
+def get_frame_files_from_gwdatafind(ifos, sites, frametypes, start, stop, seg_edge, host=None):
+    """
+    Use gwdatafind to get the frame files for the job segments
+
+    :param ifos: list of interferometers
+    :type ifos: list[str]
+    :param sites: list of sites
+    :type sites: list[str]
+    :param frametypes: list of frame types
+    :type frametypes: list[str]
+    :param start: start time of the segment
+    :type start: int or float
+    :param stop: stop time of the segment
+    :type stop: int or float
+    :param seg_edge: buffer of the segment
+    :type seg_edge: int or float
+    :param host: host name of the frame server
+    :type host: str
+
+    :return: list of frame files
+    :rtype: list[FrameFile]
+    """
+    from gwdatafind import find_urls
+
+    seg_start = start - seg_edge
+    seg_stop = stop + seg_edge
+
+    frame_list = []
+    for i, frametype in enumerate(frametypes):
+        url = find_urls(sites[i], frametype, seg_start, seg_stop, host=host)
+        frame_paths = [fp.replace("file://localhost", "") for fp in url]
+
+        for frame_path in frame_paths:
+            # get the file name without the extension with pathlib
+            frame_name = Path(frame_path).stem
+            # get the gps time and duration with int type
+            gps_start, duration = [int(i) for i in frame_name.split("-")[-2:]]
+            # append the frame file to the list
+            frame_list.append(FrameFile(ifos[i], frame_path, gps_start, duration))
+
+    return frame_list
+
+

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/modules/job_segment/job_segment.py

@@ -4,32 +4,91 @@ import orjson
 
 from .super_lag import get_slag_job_list, get_slag_list
 from .dq_segment import read_seg_list, get_seg_list, get_job_list
-from .frame import get_frame_meta, select_frame_list
+from .frame import get_frame_meta, select_frame_list, get_frame_files_from_gwdatafind
 from pycwb.types.job import WaveSegment
 from ...utils.module import import_helper
+from pycwb.modules.gracedb import get_superevent_t0
 
 logger = logging.getLogger(__name__)
 
 
 def create_job_segment_from_config(config):
+    """
+    Create job segments based on the configuration file. Currently, the following cases are supported:
+    1. pure simulation mode: only injection parameters are specified
+    2. gps_start and gps_end are specified, only one job segment will be created
+    3. gps_center, time_left, and time_right are specified, only one job segment will be created
+    4. superevent, time_left, and time_right are specified, only one job segment will be created
+    5. DQ files are specified
+
+    The frame files will be attached to the job segments if fr_files are specified.
+    Otherwise, the start and end times of the job segments can be used with the channel names to fetch the data.
+
+    :param config: The configuration object.
+    :type config: Config
+    :return:
+    :rtype: list[WaveSegment]
+    """
     logger.info("-" * 80)
     logger.info("Initializing job segments")
 
-    if not config.simulation:
-        job_segments = select_job_segment(config.dq_files, config.ifo, config.frFiles,
+
+    job_segments = None
+    periods = None
+
+    ## generate job segments based on the configuration if the DQ files or periods are specified
+    # case 1: gps_start and gps_end are specified
+    if config.gps_start and config.gps_end:
+        periods = ([config.gps_start], [config.gps_end])
+    # case 2: gps_center, time_left, and time_right are specified
+    elif config.gps_center:
+        gps_center = int(config.gps_center)
+        if not config.time_left and not config.time_right:
+            raise ValueError("Please specify either time_left or time_right for the job segment")
+        periods = ([gps_center - config.time_left], [gps_center + config.time_right])
+    # case 3: superevent, time_left, and time_right are specified
+    elif config.superevent:
+        if not config.time_left and not config.time_right:
+            raise ValueError("Please specify either time_left or time_right for the superevent")
+        gps_center = int(get_superevent_t0(config.superevent))
+        periods = ([gps_center - config.time_left], [gps_center + config.time_right])
+
+    # create job segments
+    if config.dq_files or periods:
+        # get the job segments from the DQ files
+        job_segments = job_segment_from_dq(config.dq_files, config.ifo,
                                           config.segLen, config.segMLS, config.segEdge, config.segOverlap,
-                                          config.rateANA, config.l_high)
-    else:
-        job_segments = create_job_segment_from_injection(config.ifo, config.simulation, config.injection)
-        # for job_seg in job_segments:
-        #     logger.info(job_seg)
-        # log number of segments
+                                          config.rateANA, config.l_high, config.inRate,
+                                           periods=periods)
+
+    ## if only simulation mode is specified without DQ files or periods,
+    # create job segments based on the injection parameters
+    if config.simulation and job_segments is None:
+        # TODO: split out the injection part for other job types
+        job_segments = create_job_segment_from_injection(config.ifo, config.simulation, config.injection,
+                                                         config.inRate, config.segEdge)
+
+    ## TODO: when the DQ files and simulation both are specified, inject the parameters into the job segments
+
+    # attach the frame files to the job segments if defined
+    if config.frFiles:
+        attach_frame_files_to_job_segments(job_segments, config.ifo, config.frFiles, config.segEdge)
+
+    if config.gwdatafind:
+        gwdatafind_frames_for_job_segments(job_segments, config.ifo, config.gwdatafind, config.segEdge)
+    # attach the channel names to the job segments
+    if config.channelNamesRaw:
+        for job_seg in job_segments:
+            job_seg.channels = config.channelNamesRaw
+
+    ## TODO: check if the job segments are valid
     logger.info(f"Number of segments: {len(job_segments)}")
     logger.info("-" * 80)
     return job_segments
 
 
-def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge, seg_overlap, rateANA, l_high,
+def job_segment_from_dq(dq_file_list, ifos, seg_len, seg_mls, seg_edge, seg_overlap, rateANA, l_high, sample_rate,
+                        periods=None,
                        slag_size=0, slag_off=0, slag_min=0, slag_max=0, slag_site=0, slag_file=0):
     """Select a job segment from the database.
 
@@ -37,8 +96,6 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
     :type dq_file_list: list[DQFile]
     :param ifos: The list of interferometers.
     :type ifos: list[str]
-    :param fr_files: The list of frame files.
-    :type fr_files: list[FrameFile]
     :param seg_len: The segment length.
     :type seg_len: int
     :param seg_mls: The minimum segment length after DQ_CAT1.
@@ -51,6 +108,10 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
     :type rateANA: int
     :param l_high: The high frequency cutoff.
     :type l_high: int
+    :param sample_rate: The sample rate.
+    :type sample_rate: int
+    :param periods: Given start and stop periods, will be added with the dq_file_list
+    :type periods: tuple[list[int], list[int]]
     :param slag_size: The super lag size.
     :type slag_size: int, optional
     :param slag_off: The super lag offset.
@@ -68,7 +129,7 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
     """
     if slag_size > 0:
         # TODO: not finished
-        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1')
+        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1', periods)
 
         # Get number/list of available super lag jobs
         # Compute the available segments with length=segLen contained between the interval [min,max]
@@ -91,9 +152,9 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
         raise Exception("Not finished")
 
     else:
-        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1')
+        cat1_list = read_seg_list(dq_file_list, 'CWB_CAT1', periods)
 
-        job_segments = get_job_list(ifos, cat1_list, seg_len, seg_mls, seg_edge)
+        job_segments = get_job_list(ifos, cat1_list, seg_len, seg_mls, seg_edge, sample_rate)
 
     rate_min = rateANA >> l_high
     for job_seg in job_segments:
@@ -112,6 +173,10 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
         logger.debug(f"job segment gps range = {job_seg.start_time} - {job_seg.end_time}")
     logger.info(f"Number of job segments = {len(job_segments)}")
 
+    return job_segments
+
+
+def attach_frame_files_to_job_segments(job_segments, ifos, fr_files, seg_edge):
     # Get frame file list
     frame_files = []
     for i in range(len(ifos)):
@@ -122,10 +187,35 @@ def select_job_segment(dq_file_list, ifos, fr_files, seg_len, seg_mls, seg_edge,
     for job_seg in job_segments:
         job_seg.frames = select_frame_list(frame_files, job_seg.start_time, job_seg.end_time, seg_edge)
 
-    return job_segments
+
+def gwdatafind_frames_for_job_segments(job_segments, ifos, gwdatafind, seg_edge):
+    """
+    Use gwdatafind to get the frame files for the job segments
+
+    :param job_segments: The job segments.
+    :type job_segments: list[WaveSegment]
+    :param ifos: The list of interferometers.
+    :type ifos: list[str]
+    :param gwdatafind: The gwdatafind setting.
+    :type gwdatafind: dict
+    :param seg_edge: The wavelet boundary offset.
+    :type seg_edge: int
+
+    :return: None
+    """
+    from gwdatafind import find_urls
+
+    # prepare the gwdatafind.find_urls arguments
+    if 'site' not in gwdatafind:
+        gwdatafind['site'] = [ifo[0] for ifo in ifos]
+    host = gwdatafind.get('host')
+
+    for job_seg in job_segments:
+        job_seg.frames = get_frame_files_from_gwdatafind(ifos, gwdatafind['site'], gwdatafind['frametype'],
+                                                         job_seg.start_time, job_seg.end_time, seg_edge, host=host)
 
 
-def create_job_segment_from_injection(ifo, simulation_mode, injection):
+def create_job_segment_from_injection(ifo, simulation_mode, injection, sample_rate, seg_edge):
     # get the injection parameters
     if 'parameters' in injection:
         if isinstance(injection['parameters'], list):
@@ -158,6 +248,7 @@ def create_job_segment_from_injection(ifo, simulation_mode, injection):
     if simulation_mode == "all_inject_in_one_segment":
         # inject all the parameters in one job segment
         job_segments = [WaveSegment(0, ifo, injection['segment']['start'], injection['segment']['end'],
+                                    sample_rate=sample_rate, seg_edge=seg_edge,
                                     noise=noise, injections=injections)]
     elif simulation_mode == "one_inject_in_one_segment":
         # repeat the injection N times for the same job segment
@@ -166,6 +257,7 @@ def create_job_segment_from_injection(ifo, simulation_mode, injection):
         #     raise ValueError(f"The number of injections ({len(injections)}) does not match the number of repeats ({repeat})")
 
         job_segments = [WaveSegment(i, ifo, injection['segment']['start'], injection['segment']['end'],
+                                    sample_rate=sample_rate, seg_edge=seg_edge,
                                     noise=noise, injections=[injections[i]])
                         for i in range(repeat)]
     else:

pycwb-0.24.0/pycwb/modules/job_segment/test_job_segment.py

@@ -0,0 +1,30 @@
+import unittest
+from .job_segment import read_seg_list, get_job_list
+
+class TestJobSegment(unittest.TestCase):
+    def test_read_seg_list(self):
+        periods = ([100000], [100000 + 2400])
+        expected_output = ([100000], [102400])
+        cat1_list = read_seg_list(periods=periods)
+
+        self.assertEqual(cat1_list, expected_output)
+
+    def test_get_job_list(self):
+        periods = ([100000], [100000 + 2400])
+        ifos = ['H1', 'L1']
+        seg_len = 1200
+        seg_mls = 600
+        seg_edge = 10
+        sample_rate = 4096
+        cat1_list = read_seg_list(periods=periods)
+
+        job_segments = get_job_list(ifos, cat1_list, seg_len, seg_mls, seg_edge, sample_rate)
+        self.assertEqual(len(job_segments), 2)
+        self.assertEqual(job_segments[0].start_time, 100010)
+        self.assertEqual(job_segments[0].end_time, 101200)
+        self.assertEqual(job_segments[1].start_time, 101200)
+        self.assertEqual(job_segments[1].end_time, 102390)
+
+
+if __name__ == '__main__':
+    unittest.main()

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/modules/read_data/read_data.py

@@ -185,8 +185,8 @@ def merge_frames(job_seg, data, seg_edge):
 
 def read_single_frame_from_job_segment(config, frame, job_seg: WaveSegment):
     # should read data with segment edge
-    start = job_seg.start_time - config.segEdge
-    end = job_seg.end_time + config.segEdge
+    start = job_seg.start_time - job_seg.seg_edge
+    end = job_seg.end_time + job_seg.seg_edge
 
     # for each frame, if the frame start time is later than the job segment start time, use the frame start time
     if frame.start_time > start:
@@ -196,14 +196,14 @@ def read_single_frame_from_job_segment(config, frame, job_seg: WaveSegment):
     if frame.end_time < end:
         end = frame.end_time
 
-    i = config.ifo.index(frame.ifo)
-    data = read_from_gwf(frame.path, config.channelNamesRaw[i], start=start, end=end)
+    i = job_seg.ifos.index(frame.ifo)
+    data = read_from_gwf(frame.path, job_seg.channels[i], start=start, end=end)
     print(f'Read data: start={data.t0}, duration={data.duration}, rate={data.sample_rate}')
-    if int(data.sample_rate.value) != int(config.inRate):
+    if int(data.sample_rate.value) != int(job_seg.sample_rate):
         sample_rate_old = data.sample_rate.value
         w = convert_to_wavearray(data)
-        w.Resample(config.inRate)
+        w.Resample(job_seg.sample_rate)
         data = convert_wavearray_to_timeseries(w)
         # data = data.resample(config.inRate)
-        print(f'Resample data from {sample_rate_old} to {config.inRate}')
+        print(f'Resample data from {sample_rate_old} to {job_seg.sample_rate}')
     return check_and_resample(data, config, i)

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/types/job.py

@@ -52,8 +52,14 @@ class WaveSegment:
         start time of the segment
     end_time: float
         end time of the segment
+    sample_rate: float
+        sample rate of the segment
     shift: list, optional
         list of shifts for each interferometer, used for superlags
+    seg_edge: float, optional
+        the edge of the segment
+    channels: list, optional
+        list of data  channels for each interferometer
     frames: list, optional
         list of frame files that are within the segment
     noise: dict, optional
@@ -65,8 +71,10 @@ class WaveSegment:
     ifos: List[str]
     start_time: float
     end_time: float
+    sample_rate: float
+    seg_edge: float
     shift: List[float] = None
-    seg_edge: Optional[float] = None
+    channels: Optional[List[str]] = None
     frames: Optional[List[FrameFile]] = None
     noise: Optional[Dict] = None
     injections: Optional[List[Dict]] = None

{pycwb-0.23.2 → pycwb-0.24.0}/pycwb/utils/yaml_helper.py

@@ -43,6 +43,6 @@ def set_default(params, schema):
     """
     for key in schema['properties'].keys():
         if key not in params:
-            params[key] = schema['properties'][key]['default']
+            params[key] = schema['properties'][key]['default'] if 'default' in schema['properties'][key] else None
 
     return params