so-campaign-manager 0.0.4__py3-none-any.whl

socm/workflows/ml_null_tests/moon_close_null_test.py

@@ -0,0 +1,165 @@
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import astropy.units as u
+import numpy as np
+from astral import LocationInfo
+from astropy.coordinates import AltAz, EarthLocation, SkyCoord, get_body
+from astropy.time import Time
+from pydantic import PrivateAttr
+from sotodlib.core import Context
+
+from socm.workflows.ml_null_tests import NullTestWorkflow
+
+
+class MoonCloseFarNullTestWorkflow(NullTestWorkflow):
+    """
+    A workflow for day/night null tests.
+
+    A workflow for moon proximity-based null tests.
+
+    This workflow splits observations based on whether they were taken close to or far from the moon.
+    It creates time-interleaved splits with nsplits=2 as specified.
+    """
+
+    chunk_nobs: Optional[int] = None
+    chunk_duration: Optional[timedelta] = None
+    nsplits: int = 2  # Fixed to 2 as specified in the issue
+    name: str = "moon_close_far_null_test_workflow"
+    sun_distance_threshold: float = (
+        10.0  # in degrees, threshold for close/far from the Moon
+    )
+
+    _field_view_radius_per_telescope: Dict[str, float] = PrivateAttr(
+        {"sat": 1.0, "act": 1.0, "lat": 1.0}
+    )
+
+    def _get_splits(
+        self, ctx: Context, obs_info: Dict[str, Dict[str, Union[float, str]]]
+    ) -> Dict[str, List[List[str]]]:
+        """
+        Distribute the observations across splits based on day/night.
+
+        Distribute the observations across splits based on proximity to the moon (close/far).
+
+        Groups observations by whether they were taken close to or far from the moon and then
+        creates time-interleaved splits for each with nsplits=2.
+
+        Args:
+            ctx: Context object
+            obs_info: Dictionary mapping obs_id to observation metadata
+
+        Returns:
+            Dict mapping 'day' and 'night' to list of splits, where each split is a list
+            Dict mapping 'close' and 'far' to list of splits, where each split is a list
+            of obs_ids.
+        """
+        if self.chunk_nobs is None and self.chunk_duration is None:
+            raise ValueError("Either chunk_nobs or duration must be set.")
+        elif self.chunk_nobs is not None and self.chunk_duration is not None:
+            raise ValueError("Only one of chunk_nobs or duration can be set.")
+        elif self.chunk_nobs is None:
+            # Decide the chunk size based on the duration
+            raise NotImplementedError(
+                "Splitting by duration is not implemented yet. Please set chunk_nobs."
+            )
+
+        # Group observations by day/night
+        moon_position_splits = {"close": [], "far": []}
+        for obs_id, obs_meta in obs_info.items():
+            obs_time = datetime.fromtimestamp(
+                timestamp=obs_meta["start_time"], tz=timezone.utc
+            )  # Assuming time is in ISO format
+            obs_time = Time(obs_meta["start_time"], format="unix", scale="utc")
+
+            city = LocationInfo(
+                "San Pedro de Atacama", "Chile", "America/Santiago", -22.91, -68.2
+            )
+            alt = 5190  # Altitude in meters
+            location = EarthLocation(
+                lat=city.latitude * u.deg, lon=city.longitude * u.deg, height=alt * u.m
+            )
+            altaz = AltAz(obstime=obs_time, location=location)
+            altaz_coord = SkyCoord(
+                az=obs_meta["az_center"] * u.deg,
+                alt=obs_meta["el_center"] * u.deg,
+                frame=altaz,
+            )
+            radec = altaz_coord.transform_to("icrs")
+
+            # Get Moon's position
+            moon = get_body("moon", obs_time, location=location)
+
+            # Compute angular separation
+            separation = radec.separation(moon)
+
+            if separation.deg <= (
+                self.sun_distance_threshold
+                + self._field_view_radius_per_telescope[self.site]
+            ):
+                moon_position_splits["close"].append(obs_id)
+            else:
+                moon_position_splits["far"].append(obs_id)
+
+        final_splits = {}
+
+        # For each direction, create time-interleaved splits
+        for moon_position, obs_infos in moon_position_splits.items():
+            if not obs_infos:
+                continue
+
+            # Sort by timestamp for time-based splitting
+            sorted_ids = sorted(obs_infos, key=lambda k: obs_info[k]["start_time"])
+
+            # Group in chunks based on chunk_nobs
+            num_chunks = self._get_num_chunks(len(sorted_ids))
+            obs_lists = np.array_split(sorted_ids, num_chunks) if num_chunks > 0 else []
+
+            # Create nsplits (=2) time-interleaved splits
+            splits = [[] for _ in range(self.nsplits)]
+            for i, obs_list in enumerate(obs_lists):
+                splits[i % self.nsplits] += obs_list.tolist()
+
+            final_splits[moon_position] = splits
+
+        return final_splits
+
+    @classmethod
+    def get_workflows(cls, desc=None) -> List[NullTestWorkflow]:
+        """
+        Create a list of NullTestWorkflows instances from the provided descriptions.
+
+        Creates separate workflows for each direction split following the naming
+        convention: {setname} = direction_[rising,setting,middle]
+        """
+        moon_position_workflow = cls(**desc)
+
+        workflows = []
+        for (
+            moon_position,
+            moon_position_splits,
+        ) in moon_position_workflow._splits.items():
+            for split_idx, split in enumerate(moon_position_splits):
+                if not split:
+                    continue
+                desc_copy = moon_position_workflow.model_dump(exclude_unset=True)
+                desc_copy["name"] = (
+                    f"moon_{moon_position}_split_{split_idx + 1}_null_test_workflow"
+                )
+                # Follow the naming convention: direction_[rising,setting,middle]
+                desc_copy["output_dir"] = (
+                    f"{moon_position_workflow.output_dir}/moon_{moon_position}_split_{split_idx + 1}"
+                )
+                desc_copy["datasize"] = 0
+                query_file = Path(desc_copy["output_dir"]) / "query.txt"
+                query_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(query_file, "w") as f:
+                    for oid in split:
+                        f.write(f"{oid}\n")
+                desc_copy["query"] = f"file://{str(query_file.absolute())}"
+                desc_copy["chunk_nobs"] = 1
+                workflow = NullTestWorkflow(**desc_copy)
+                workflows.append(workflow)
+
+        return workflows

socm/workflows/ml_null_tests/moonrise_set_null_test.py

@@ -0,0 +1,151 @@
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+from astral import LocationInfo
+from astral.moon import moonrise, moonset
+from sotodlib.core import Context
+
+from socm.workflows.ml_null_tests import NullTestWorkflow
+
+
+class MoonRiseSetNullTestWorkflow(NullTestWorkflow):
+    """
+    A workflow for moonrise/moonset null tests.
+
+    This workflow splits observations based on whether they were taken during the moonrise or moonset.
+    It creates time-interleaved splits with nsplits=2 as specified.
+    """
+
+    chunk_nobs: Optional[int] = None
+    chunk_duration: Optional[timedelta] = None
+    nsplits: int = 2  # Fixed to 2 as specified in the issue
+    name: str = "moonset_null_test_workflow"
+
+    def _get_splits(
+        self, ctx: Context, obs_info: Dict[str, Dict[str, Union[float, str]]]
+    ) -> Dict[str, List[List[str]]]:
+        """
+        Distribute the observations across splits based on day/night.
+
+        Groups observations by whether they were taken during the day or night and then
+        creates time-interleaved splits for each with nsplits=2.
+
+        Args:
+            ctx: Context object
+            obs_info: Dictionary mapping obs_id to observation metadata
+
+        Returns:
+            Dict mapping 'day' and 'night' to list of splits, where each split is a list
+            of obs_ids
+        """
+        if self.chunk_nobs is None and self.chunk_duration is None:
+            raise ValueError("Either chunk_nobs or duration must be set.")
+        elif self.chunk_nobs is not None and self.chunk_duration is not None:
+            raise ValueError("Only one of chunk_nobs or duration can be set.")
+        elif self.chunk_nobs is None:
+            # Decide the chunk size based on the duration
+            raise NotImplementedError(
+                "Splitting by duration is not implemented yet. Please set chunk_nobs."
+            )
+
+        # Group observations by day/night
+        moon_sky_splits = {"insky": [], "outsky": []}
+        for obs_id, obs_meta in obs_info.items():
+            obs_time = datetime.fromtimestamp(
+                timestamp=obs_meta["start_time"], tz=timezone.utc
+            )  # Assuming time is in ISO format
+
+            # Determine if it's day or night using the sun position
+            city = LocationInfo(
+                "San Pedro de Atacama", "Chile", "America/Santiago", -22.91, -68.2
+            )
+            moon_rise = moonrise(city.observer, obs_time, timezone.utc)
+            moon_set = moonset(city.observer, obs_time, timezone.utc)
+
+            moon_times = []
+            if moon_set.hour < moon_rise.hour:
+                # Moon sets on a different day
+                start_of_day = obs_time.replace(
+                    hour=0, minute=0, second=0, microsecond=0
+                )
+                end_of_day = obs_time.replace(
+                    hour=23, minute=59, second=59, microsecond=999999
+                )
+                moon_times = [
+                    {"start_time": start_of_day, "end_time": moon_set},
+                    {"start_time": moon_rise, "end_time": end_of_day},
+                ]
+            else:
+                # Moon sets on the same day
+                moon_times = [{"start_time": moon_rise, "end_time": moon_set}]
+            moon_in_sky = False
+            for mt in moon_times:
+                if mt["start_time"] <= obs_time <= mt["end_time"]:
+                    moon_in_sky = True
+                    break
+            if moon_in_sky:
+                moon_sky_splits["insky"].append(obs_id)
+            else:
+                moon_sky_splits["outsky"].append(obs_id)
+
+        final_splits = {}
+
+        # For each direction, create time-interleaved splits
+        for moon_sky, obs_infos in moon_sky_splits.items():
+            if not obs_infos:
+                continue
+
+            # Sort by timestamp for time-based splitting
+            sorted_ids = sorted(obs_infos, key=lambda k: obs_info[k]["start_time"])
+
+            # Group in chunks based on chunk_nobs
+            num_chunks = self._get_num_chunks(len(sorted_ids))
+            obs_lists = np.array_split(sorted_ids, num_chunks) if num_chunks > 0 else []
+
+            # Create nsplits (=2) time-interleaved splits
+            splits = [[] for _ in range(self.nsplits)]
+            for i, obs_list in enumerate(obs_lists):
+                splits[i % self.nsplits] += obs_list.tolist()
+
+            final_splits[moon_sky] = splits
+
+        return final_splits
+
+    @classmethod
+    def get_workflows(cls, desc=None) -> List[NullTestWorkflow]:
+        """
+        Create a list of NullTestWorkflows instances from the provided descriptions.
+
+        Creates separate workflows for each direction split following the naming
+        convention: {setname} = direction_[rising,setting,middle]
+        """
+        moon_sky_workflow = cls(**desc)
+
+        workflows = []
+        for moon_sky, moon_sky_splits in moon_sky_workflow._splits.items():
+            for split_idx, split in enumerate(moon_sky_splits):
+                if not split:
+                    continue
+                desc_copy = moon_sky_workflow.model_dump(exclude_unset=True)
+                desc_copy["name"] = (
+                    f"moon_{moon_sky}_split_{split_idx + 1}_null_test_workflow"
+                )
+
+                # Follow the naming convention: direction_[rising,setting,middle]
+                desc_copy["output_dir"] = (
+                    f"{moon_sky_workflow.output_dir}/moon_{moon_sky}_split_{split_idx + 1}"
+                )
+                desc_copy["datasize"] = 0
+                query_file = Path(desc_copy["output_dir"]) / "query.txt"
+                query_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(query_file, "w") as f:
+                    for oid in split:
+                        f.write(f"{oid}\n")
+                desc_copy["query"] = f"file://{str(query_file.absolute())}"
+                desc_copy["chunk_nobs"] = 1
+                workflow = NullTestWorkflow(**desc_copy)
+                workflows.append(workflow)
+
+        return workflows

socm/workflows/ml_null_tests/pwv_null_test.py

@@ -0,0 +1,118 @@
+from datetime import timedelta
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+from sotodlib.core import Context
+
+from socm.workflows.ml_null_tests import NullTestWorkflow
+
+
+class PWVNullTestWorkflow(NullTestWorkflow):
+    """
+    A workflow for PWV (precipitable water vapor) null tests.
+
+    This workflow splits observations into two groups based on PWV levels ('high' and 'low')
+    and creates time-interleaved splits with nsplits=2 as specified.
+    """
+
+    chunk_nobs: Optional[int] = None
+    chunk_duration: Optional[timedelta] = None
+    pwv_limit: float = 2.0  # Example limit for PWV, adjust as needed
+    nsplits: int = 2  # Fixed to 2 as specified in the issue
+    name: str = "pwv_null_test_workflow"
+
+    def _get_splits(
+        self, ctx: Context, obs_info: Dict[str, Dict[str, Union[float, str]]]
+    ) -> Dict[str, List[List[str]]]:
+        """
+        Distribute the observations across splits based on PWV values.
+
+        Groups observations by PWV level (high, low) and then
+        creates time-interleaved splits for each level with nsplits=2.
+
+        Args:
+            ctx: Context object
+            obs_info: Dictionary mapping obs_id to observation metadata
+
+        Returns:
+            Dict mapping PWV level to list of splits, where each split is a list
+            of obs_ids
+        """
+        if self.chunk_nobs is None and self.chunk_duration is None:
+            raise ValueError("Either chunk_nobs or duration must be set.")
+        elif self.chunk_nobs is not None and self.chunk_duration is not None:
+            raise ValueError("Only one of chunk_nobs or duration can be set.")
+        elif self.chunk_nobs is None:
+            # Decide the chunk size based on the duration
+            raise NotImplementedError(
+                "Splitting by duration is not implemented yet. Please set chunk_nobs."
+            )
+
+        # Group observations by scan direction
+        pwv_splits = {"high": [], "low": []}
+        for obs_id, obs_meta in obs_info.items():
+            if obs_meta["pwv"] > self.pwv_limit:
+                pwv_splits["high"].append(obs_id)
+            else:
+                pwv_splits["low"].append(obs_id)
+
+        final_splits = {}
+
+        # For each pwv level, create time-interleaved splits
+        for pwv_level, pwv_obs_info in pwv_splits.items():
+            if not pwv_obs_info:
+                continue
+
+            # Sort by timestamp for time-based splitting
+            sorted_ids = sorted(pwv_obs_info, key=lambda k: obs_info[k]["start_time"])
+
+            # Group in chunks based on chunk_nobs
+            num_chunks = self._get_num_chunks(len(sorted_ids))
+            obs_lists = np.array_split(sorted_ids, num_chunks) if num_chunks > 0 else []
+
+            # Create nsplits (=2) time-interleaved splits
+            splits = [[] for _ in range(self.nsplits)]
+            for i, obs_list in enumerate(obs_lists):
+                splits[i % self.nsplits] += obs_list.tolist()
+
+            final_splits[pwv_level] = splits
+
+        return final_splits
+
+    @classmethod
+    def get_workflows(cls, desc=None) -> List[NullTestWorkflow]:
+        """
+        Create a list of NullTestWorkflows instances from the provided descriptions.
+
+        Creates separate workflows for each PWV-based split following the naming
+        convention: {setname} = pwv_{pwv_level}_split_{split_idx + 1}_null_test_workflow
+        """
+        pwv_workflow = cls(**desc)
+
+        workflows = []
+        for pwv_level, pwv_splits in pwv_workflow._splits.items():
+            for split_idx, split in enumerate(pwv_splits):
+                if not split:
+                    continue
+                desc_copy = pwv_workflow.model_dump(exclude_unset=True)
+                desc_copy["name"] = (
+                    f"pwv_{pwv_level}_split_{split_idx + 1}_null_test_workflow"
+                )
+
+                # Follow the naming convention: pwv_[high,low]
+                desc_copy["output_dir"] = (
+                    f"{pwv_workflow.output_dir}/pwv_{pwv_level}_split_{split_idx + 1}"
+                )
+                desc_copy["datasize"] = 0
+                query_file = Path(desc_copy["output_dir"]) / "query.txt"
+                query_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(query_file, "w") as f:
+                    for oid in split:
+                        f.write(f"{oid}\n")
+                desc_copy["query"] = f"file://{str(query_file.absolute())}"
+                desc_copy["chunk_nobs"] = 1
+                workflow = NullTestWorkflow(**desc_copy)
+                workflows.append(workflow)
+
+        return workflows

socm/workflows/ml_null_tests/sun_close_null_test.py

@@ -0,0 +1,173 @@
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import astropy.units as u
+import numpy as np
+from astral import LocationInfo
+from astropy.coordinates import AltAz, EarthLocation, SkyCoord, get_sun
+from astropy.time import Time
+from pydantic import PrivateAttr
+from sotodlib.core import Context
+
+from socm.workflows.ml_null_tests import NullTestWorkflow
+
+
+class SunCloseFarNullTestWorkflow(NullTestWorkflow):
+    """
+    A workflow for day/night null tests.
+
+    This workflow splits observations based on whether they were taken during the day or night.
+    A workflow for sun proximity-based null tests.
+
+    This workflow splits observations based on whether they are "close" or "far" from the Sun,
+    using a configurable sun distance threshold (in degrees). It creates time-interleaved splits
+    with nsplits=2 as specified.
+    """
+
+    chunk_nobs: Optional[int] = None
+    chunk_duration: Optional[timedelta] = None
+    nsplits: int = 2  # Fixed to 2 as specified in the issue
+    name: str = "sun_close_far_null_test_workflow"
+    sun_distance_threshold: float = (
+        10.0  # in degrees, threshold for close/far from the Sun
+    )
+
+    _field_view_radius_per_telescope: Dict[str, float] = PrivateAttr(
+        {"sat": 1.0, "act": 1.0, "lat": 1.0}
+    )
+
+    def _get_splits(
+        self, ctx: Context, obs_info: Dict[str, Dict[str, Union[float, str]]]
+    ) -> Dict[str, List[List[str]]]:
+        """
+        Distribute the observations across splits based on day/night.
+
+        Groups observations by whether they were taken during the day or night and then
+        creates time-interleaved splits for each with nsplits=2.
+
+        Args:
+            ctx: Context object
+            obs_info: Dictionary mapping obs_id to observation metadata
+
+        Returns:
+        Distribute the observations across splits based on proximity to the sun.
+
+        Groups observations by whether they are 'close' or 'far' from the sun, according to
+        the sun_distance_threshold, and then creates time-interleaved splits for each group
+        with nsplits=2.
+
+        Args:
+            ctx: Context object
+            obs_info: Dictionary mapping obs_id to observation metadata
+
+        Returns:
+            Dict mapping 'close' and 'far' to list of splits, where each split is a list
+            of obs_ids
+        """
+        if self.chunk_nobs is None and self.chunk_duration is None:
+            raise ValueError("Either chunk_nobs or duration must be set.")
+        elif self.chunk_nobs is not None and self.chunk_duration is not None:
+            raise ValueError("Only one of chunk_nobs or duration can be set.")
+        elif self.chunk_nobs is None:
+            # Decide the chunk size based on the duration
+            raise NotImplementedError(
+                "Splitting by duration is not implemented yet. Please set chunk_nobs."
+            )
+
+        # Group observations by day/night
+        sun_position_splits = {"close": [], "far": []}
+        for obs_id, obs_meta in obs_info.items():
+            obs_time = datetime.fromtimestamp(
+                timestamp=obs_meta["start_time"], tz=timezone.utc
+            )  # Assuming time is in ISO format
+            obs_time = Time(obs_meta["start_time"], format="unix", scale="utc")
+
+            city = LocationInfo(
+                "San Pedro de Atacama", "Chile", "America/Santiago", -22.91, -68.2
+            )
+            alt = 5190  # Altitude in meters
+            location = EarthLocation(
+                lat=city.latitude * u.deg, lon=city.longitude * u.deg, height=alt * u.m
+            )
+            altaz = AltAz(obstime=obs_time, location=location)
+            altaz_coord = SkyCoord(
+                az=obs_meta["az_center"] * u.deg,
+                alt=obs_meta["el_center"] * u.deg,
+                frame=altaz,
+            )
+            radec = altaz_coord.transform_to("icrs")
+
+            # Get Sun's position
+            sun = get_sun(obs_time)
+
+            # Compute angular separation
+            separation = radec.separation(sun)
+
+            if separation.deg <= (
+                self.sun_distance_threshold
+                + self._field_view_radius_per_telescope[self.site]
+            ):
+                sun_position_splits["close"].append(obs_id)
+            else:
+                sun_position_splits["far"].append(obs_id)
+
+        final_splits = {}
+
+        # For each direction, create time-interleaved splits
+        for sun_position, obs_infos in sun_position_splits.items():
+            if not obs_infos:
+                continue
+
+            # Sort by timestamp for time-based splitting
+            sorted_ids = sorted(obs_infos, key=lambda k: obs_info[k]["start_time"])
+
+            # Group in chunks based on chunk_nobs
+            num_chunks = self._get_num_chunks(len(sorted_ids))
+            obs_lists = np.array_split(sorted_ids, num_chunks) if num_chunks > 0 else []
+
+            # Create nsplits (=2) time-interleaved splits
+            splits = [[] for _ in range(self.nsplits)]
+            for i, obs_list in enumerate(obs_lists):
+                splits[i % self.nsplits] += obs_list.tolist()
+
+            final_splits[sun_position] = splits
+
+        return final_splits
+
+    @classmethod
+    def get_workflows(cls, desc=None) -> List[NullTestWorkflow]:
+        """
+        Create a list of NullTestWorkflows instances from the provided descriptions.
+
+        Creates separate workflows for each direction split following the naming
+        convention: {setname} = direction_[rising,setting,middle]
+        """
+        sun_position_workflow = cls(**desc)
+
+        workflows = []
+        for sun_position, sun_position_splits in sun_position_workflow._splits.items():
+            for split_idx, split in enumerate(sun_position_splits):
+                if not split:
+                    continue
+                desc_copy = sun_position_workflow.model_dump(exclude_unset=True)
+                desc_copy["name"] = (
+                    f"sun_{sun_position}_split_{split_idx + 1}_null_test_workflow"
+                )
+
+                # Follow the naming convention: direction_[rising,setting,middle]
+                desc_copy["output_dir"] = (
+                    f"{sun_position_workflow.output_dir}/sun_{sun_position}_split_{split_idx + 1}"
+                )
+                desc_copy["datasize"] = 0
+                query_file = Path(desc_copy["output_dir"]) / "query.txt"
+                query_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(query_file, "w") as f:
+                    for oid in split:
+                        f.write(f"{oid}\n")
+                desc_copy["query"] = f"file://{str(query_file.absolute())}"
+                desc_copy["chunk_nobs"] = 1
+                workflow = NullTestWorkflow(**desc_copy)
+                workflows.append(workflow)
+
+        return workflows

socm/workflows/ml_null_tests/time_null_test.py

@@ -0,0 +1,76 @@
+from datetime import timedelta
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+from sotodlib.core import Context
+
+from socm.workflows.ml_null_tests import NullTestWorkflow
+
+
+class TimeNullTestWorkflow(NullTestWorkflow):
+    """
+    A workflow for time null tests.
+    """
+
+    chunk_nobs: Optional[int] = None
+    chunk_duration: Optional[timedelta] = None
+    nsplits: int = 8
+    name: str = "time_null_test_workflow"
+
+    def _get_splits(
+        self, ctx: Context, obs_info: Dict[str, Dict[str, Union[float, str]]]
+    ) -> List[List[str]]:
+        """
+        Distribute the observations across splits based on the context and observation IDs.
+        """
+        if self.chunk_nobs is None and self.chunk_duration is None:
+            raise ValueError("Either chunk_nobs or duration must be set.")
+        elif self.chunk_nobs is not None and self.chunk_duration is not None:
+            raise ValueError("Only one of chunk_nobs or duration can be set.")
+        elif self.chunk_nobs is None:
+            # Decide the chunk size based on the duration. Each chunk needs to have the
+            # observations that their start times are just less than chunk_duration.
+            raise NotImplementedError(
+                "Splitting by duration is not implemented yet. Please set chunk_nobs."
+            )
+
+        sorted_ids = sorted(obs_info, key=lambda k: obs_info[k]["start_time"])
+        # Group in chunks of size self.chunk_nobs observations.
+        num_chunks = self._get_num_chunks(len(sorted_ids))
+        obs_lists = np.array_split(sorted_ids, num_chunks) if num_chunks > 0 else []
+        splits = [[] for _ in range(self.nsplits)]
+        for i, obs_list in enumerate(obs_lists):
+            splits[i % self.nsplits] += obs_list.tolist()
+
+        return splits
+
+    @classmethod
+    def get_workflows(cls, desc=None) -> List[NullTestWorkflow]:
+        """
+        Create a list of NullTestWorkflows instances from the provided descriptions.
+        """
+
+        time_workflow = cls(**desc)
+
+        workflows = []
+        for split in time_workflow._splits:
+            if not split:
+                continue
+            desc = time_workflow.model_dump(exclude_unset=True)
+            desc["name"] = f"mission_split_{len(workflows) + 1}_null_test_workflow"
+            desc["output_dir"] = (
+                f"{time_workflow.output_dir}/mission_split_{len(workflows) + 1}"
+            )
+            desc["datasize"] = 0
+            query_file = Path(desc["output_dir"]) / "query.txt"
+            query_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(query_file, "w") as f:
+                for oid in split:
+                    f.write(f"{oid}\n")
+            desc["query"] = f"file://{str(query_file.absolute())}"
+            desc["chunk_nobs"] = 1
+            workflow = NullTestWorkflow(**desc)
+            workflows.append(workflow)
+
+        return workflows