nullpol 0.1.1__tar.gz → 0.1.2__tar.gz

{nullpol-0.1.1 → nullpol-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nullpol
-Version: 0.1.1
+Version: 0.1.2
 Summary: A package to perform model-independent polarization test of gravitational-wave signals.
 Author: Thomas Ng, Balázs Cirok
 Author-email: "Isaac C.F. Wong" <chunfung.wong@kuleuven.be>

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/__init__.py

@@ -5,7 +5,7 @@ from . import (asimov, calibration, clustering, detector, injection,
                time_frequency_transform, utils)
 from .utils import logger
 
-__version__ = '0.1.1'
+__version__ = '0.1.2'
 
 
 def get_version_information() -> str:

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/asimov/asimov.py

@@ -12,9 +12,6 @@ from asimov import config
 from asimov.pipeline import Pipeline, PipelineException, PipelineLogger
 from asimov.pipelines.bilby import Bilby
 
-from .pesummary import PESummaryPipeline
-
-
 class Nullpol(Bilby):
     """
     The nullpol pipeline.
@@ -86,13 +83,33 @@ class Nullpol(Bilby):
         ) + glob.glob(os.path.join(rundir, "result", f"*_{subrun_label}_merge*_result.json"))
 
     def after_completion(self):
-        post_pipeline = PESummaryPipeline(production=self.production)
-        self.logger.info("Job has completed. Running PE Summary.")
-        cluster = post_pipeline.submit_dag()
-        self.production.meta["job id"] = int(cluster)
+        """Wait for the PEsummary node that is part of the analysis DAG."""
+        if self.detect_completion_processing():
+            self.after_processing()
+            return
+
+        self.logger.info("Analysis DAG completed; waiting for its PE summary.")
         self.production.status = "processing"
         self.production.event.update_data()
 
+    def detect_completion_processing(self):
+        """Check for the combined PEsummary result produced by the DAG."""
+        result = os.path.join(
+            config.get("general", "webroot"),
+            self.production.event.name,
+            self.production.name,
+            "pesummary",
+            "samples",
+            "posterior_samples.h5",
+        )
+        return os.path.isfile(result)
+
+    def after_processing(self):
+        """Publish the completed DAG-contained PEsummary result."""
+        self.logger.info("DAG-contained PE summary is available.")
+        self.production.status = "uploaded"
+        self.production.event.update_data()
+
     @property
     def config_file_path(self):
         """Path of the configuration file.

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/asimov/nullpol.ini

@@ -115,6 +115,7 @@ request-memory-generation={{ scheduler['request generation memory'] | default: N
 request-cpus={{ scheduler['request cpus'] | default: 1 }}
 request-disk={{ scheduler['request disk'] | default: 1 }}
 scheduler={{ scheduler['type'] | default: 'condor' }}
+requirements={{ scheduler['requirements'] | default: None }}
 scheduler-args=None
 scheduler-module=None
 scheduler-env=None
@@ -125,6 +126,7 @@ online-pe=False
 osg={{ scheduler['osg'] | default: False }}
 desired-sites={{ scheduler['desired sites'] | default: None }}
 analysis-executable={{ config['pipelines']['environment'] }}/bin/nullpol_pipe_analysis
+conda-env={{ config['pipelines']['environment'] }}
 environment-variables={{ scheduler['environment variables'] | default: "{'HDF5_USE_FILE_LOCKING': False, 'OMP_NUM_THREADS'=1, 'OMP_PROC_BIND'=False}" }}
 
 ################################################################################
@@ -155,13 +157,13 @@ plot-marginal=False
 plot-skymap=True
 plot-waveform=False
 plot-format=png
-create-summary=False
+create-summary=True
 email=None
 notification=Error
 queue=None
 existing-dir=None
-webdir={{ config['general']['webroot'] }}/{{ production.event.name }}/{{ production.name }}
-summarypages-arguments=None
+webdir={{ config['general']['webroot'] }}/{{ production.event.name }}/{{ production.name }}/pesummary
+summarypages-arguments={gw: True}
 result-format=hdf5
 final-result=True
 final-result-nsamples=20000
@@ -239,6 +241,7 @@ sampler-kwargs={{ sampler['sampler kwargs'] |  default: "{'nlive': 1000, 'naccep
 time-frequency-clustering-method={{ likelihood['time frequency clustering method'] | default: 'maxL' }}
 time-frequency-clustering-injection-parameters-filename={{ likelihood['time frequency clustering injection parameters filename'] | default: None}}
 time-frequency-clustering-pe-samples-filename={{ likelihood['time frequency clustering pe samples filename'] | default: gr_pe_info['result file path']}}
+time-frequency-filter-file={{ likelihood['time frequency filter file'] | default: None}}
 time-frequency-clustering-threshold={{ likelihood['time frequency clustering threshold'] | default: 1.0 }}
 time-frequency-clustering-threshold-type={{ likelihood['time frequency clustering threshold type'] | default: 'variance' }}
 time-frequency-clustering-time-padding={{ likelihood['time frequency clustering time padding'] | default: 0.1 }}

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/asimov/tgrflow.py

@@ -560,6 +560,8 @@ class Applicator:
             output['psds'] = {}
             for key, value in gr_pe['psds'].items():
                 filename = os.path.join(copied_data_folder, f'{key}_psd.dat')
+                if os.path.exists(filename):
+                    os.chmod(filename, 0o644)
                 shutil.copy(value, filename)
                 output['psds'][key] = filename
         event = Event.from_dict(output)

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/injection/injection.py

@@ -4,7 +4,7 @@ from bilby.gw.conversion import convert_to_lal_binary_black_hole_parameters
 from bilby.gw.source import lal_binary_black_hole
 from bilby.gw.waveform_generator import WaveformGenerator
 
-DEFAULT_BBH_WAVEFORM_ARGUMENTS = {"waveform_approximant": "IMRPhenomPv2",
+DEFAULT_BBH_WAVEFORM_ARGUMENTS = {"waveform_approximant": "IMRPhenomXPHM",
                                   "reference_frequency": 50}
 
 

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/job_creation/nullpol_pipe_dag_creator.py

@@ -7,13 +7,14 @@ from bilby_pipe.job_creation.bilby_pipe_dag_creator import (
     get_parallel_list, get_trigger_time_list)
 from bilby_pipe.job_creation.dag import Dag
 from bilby_pipe.job_creation.nodes import (FinalResultNode, MergeNode,
-                                           PESummaryNode, PlotNode,
+                                           PlotNode,
                                            PostProcessAllResultsNode,
                                            PostProcessSingleResultsNode)
 from bilby_pipe.job_creation.overview import create_overview
 from bilby_pipe.utils import get_colored_string
 
 from ..utils import NullpolError, logger
+from .pe_summary_node import NullpolPESummaryNode as PESummaryNode
 from .analysis_node import AnalysisNode
 from .generation_node import GenerationNode
 

nullpol-0.1.2/src/nullpol/job_creation/pe_summary_node.py

@@ -0,0 +1,47 @@
+import copy
+import re
+
+from bilby_pipe.job_creation.nodes import PESummaryNode
+
+
+class NullpolPESummaryNode(PESummaryNode):
+    """PESummaryNode that:
+
+    - Passes --psd and --calibration from the bilby_pipe config to the
+      summarypages command (bilby_pipe's PESummaryNode has access to these
+      for HTCondor file-transfer but does not add them as command arguments,
+      so PESummary cannot generate PSD or calibration plots without this).
+
+    - Shortens the auto-generated labels from bilby_pipe's full run ID
+      (e.g. nullpol_data0_..._analysis_H1L1V1_pc_p_merge) to just the
+      polarization mode and basis (e.g. pc_p).
+    """
+
+    def __init__(self, inputs, merged_node_list, generation_node_list, dag):
+        self._n_results = len(merged_node_list)
+
+        short_labels = [
+            re.sub(r'^.*_analysis_[A-Z0-9]+_(.+)_merge$', r'\1', node.label)
+            for node in merged_node_list
+        ]
+
+        # Shallow-copy inputs so we don't mutate the shared object, then
+        # replace summarypages_arguments with a new dict that includes labels.
+        inputs = copy.copy(inputs)
+        base_args = inputs.summarypages_arguments or {}
+        inputs.summarypages_arguments = {**base_args, "labels": short_labels}
+
+        super().__init__(inputs, merged_node_list, generation_node_list, dag)
+
+    def process_node(self):
+        psd_dict = self.inputs.psd_dict
+        if psd_dict:
+            psd_str = " ".join(f"{ifo}:{path}" for ifo, path in psd_dict.items())
+            self.arguments.add("psd", (" " + psd_str) * self._n_results)
+
+        cal_dict = self.inputs.spline_calibration_envelope_dict
+        if cal_dict:
+            cal_str = " ".join(f"{ifo}:{path}" for ifo, path in cal_dict.items())
+            self.arguments.add("calibration", (" " + cal_str) * self._n_results)
+
+        super().process_node()

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/source/simple_map.py

@@ -11,7 +11,7 @@ def lal_binary_black_hole_non_gr_simple_map(
     **kwargs,
 ):
     waveform_kwargs = dict(
-        waveform_approximant='IMRPhenomPv2', reference_frequency=50.0,
+        waveform_approximant='IMRPhenomXPHM', reference_frequency=50.0,
         minimum_frequency=20.0, maximum_frequency=frequency_array[-1],
         catch_waveform_errors=False, pn_spin_order=-1, pn_tidal_order=-1,
         pn_phase_order=-1, pn_amplitude_order=0)

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/tools/config.ini

@@ -312,7 +312,7 @@ waveform-generator=bilby.gw.waveform_generator.LALCBCWaveformGenerator
 # The reference frequency
 reference-frequency=20
 # The name of the waveform approximant to use for PE.
-waveform-approximant=IMRPhenomPv2
+waveform-approximant=IMRPhenomXPHM
 # Turns on waveform error catching
 catch-waveform-errors=True
 # Post-newtonian order to use for the spin
@@ -345,8 +345,10 @@ generation-function=None
 time-frequency-clustering-method=None
 # If `injection_parameters_file` is chosen in --time-frequency-clustering-method, provide the path to the injection parameters file.
 time-frequency-clustering-injection-parameters-filename=None
-# If `maxL`, `maxP` or `random` is chosen in --time-frequency-clustering-method, provide the path to the bilby result file.
+# If `maxL`, `maP` or `random` is chosen in --time-frequency-clustering-method, provide the path to the bilby result file.
 time-frequency-clustering-pe-samples-filename=None
+# Path to a previously saved NumPy time-frequency filter. When supplied, it takes precedence over time-frequency-clustering-method.
+time-frequency-filter-file=None
 # Quantile threshold to filter the excess power.
 time-frequency-clustering-threshold=0.95
 # Type of threshold.

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/tools/data_generation.py

@@ -4,9 +4,7 @@ import sys
 
 import bilby
 import bilby_pipe.utils
-import h5py
 import numpy as np
-import pandas as pd
 from bilby_pipe.data_generation import \
     DataGenerationInput as BilbyDataGenerationInput
 from bilby_pipe.main import parse_args
@@ -130,6 +128,7 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
         self.time_frequency_clustering_method = args.time_frequency_clustering_method
         self.time_frequency_clustering_injection_parameters_filename = args.time_frequency_clustering_injection_parameters_filename
         self.time_frequency_clustering_pe_samples_filename = args.time_frequency_clustering_pe_samples_filename
+        self.time_frequency_filter_file = args.time_frequency_filter_file
         self.time_frequency_clustering_threshold = args.time_frequency_clustering_threshold
         self.time_frequency_clustering_threshold_type = args.time_frequency_clustering_threshold_type
         self.time_frequency_clustering_time_padding = args.time_frequency_clustering_time_padding
@@ -224,8 +223,12 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
 
     def run_time_frequency_clustering(self):
         logger.info(f"Running time-frequency clustering with method: {self.time_frequency_clustering_method}")
+        if self.time_frequency_filter_file is not None:
+            time_frequency_filter = np.load(self.time_frequency_filter_file, allow_pickle=False)
+            sky_maximized_spectrogram = None
+            logger.info(f"Loaded time-frequency filter from {self.time_frequency_filter_file}.")
         # Build the strain data for time-frequency clustering
-        if self.time_frequency_clustering_method in [
+        elif self.time_frequency_clustering_method in [
                 "data",
                 "injection",
                 "injection_parameters_file",
@@ -239,6 +242,12 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
                                                            "maxL",
                                                            "maP",
                                                            "random"]:
+                if self.time_frequency_clustering_method in [
+                        "injection", "injection_parameters_file"]:
+                    waveform_generator_class = self.waveform_generator_class
+                    frequency_domain_source_model = self.bilby_frequency_domain_source_model
+                    parameter_conversion = self.parameter_conversion
+                    waveform_arguments = self.get_injection_waveform_arguments()
                 if self.time_frequency_clustering_method == "injection":
                     parameters = self.meta_data["injection_parameters"]
                 elif self.time_frequency_clustering_method == "injection_parameters_file":
@@ -255,17 +264,25 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
                     if self.time_frequency_clustering_pe_samples_filename is None:
                         raise NullpolError(f"time-frequency-clustering-method = {self.time_frequency_clustering_method}, but time-frequency-clustering-pe-samples-filename is not provided.")
                     try:
-                        posterior = bilby.core.result.read_in_result(self.time_frequency_clustering_pe_samples_filename).posterior
-                    except:
-                        logger.warning(f"Trying to read the posterior as a .h5 file.")
-                        with h5py.File(self.time_frequency_clustering_pe_samples_filename, "r") as f:
-                            posterior = pd.DataFrame(f[list(f.keys())[0]]['posterior_samples'][()]) # Use the first waveform result
+                        pe_result = bilby.core.result.read_in_result(
+                            self.time_frequency_clustering_pe_samples_filename)
+                        posterior = pe_result.posterior
+                        pe_waveform = pe_result.meta_data["likelihood"]
+                        waveform_generator_class = pe_waveform["waveform_generator_class"]
+                        frequency_domain_source_model = pe_waveform["frequency_domain_source_model"]
+                        parameter_conversion = pe_waveform["parameter_conversion"]
+                        waveform_arguments = pe_waveform["waveform_arguments"]
+                    except Exception as exception:
+                        raise NullpolError(
+                            "Unable to recover the waveform metadata from the Bilby PE result. "
+                            "PE-driven time-frequency clustering requires a Bilby result with "
+                            "likelihood waveform metadata.") from exception
                     if self.time_frequency_clustering_method == "maxL":
                         parameters = posterior.loc[posterior["log_likelihood"].idxmax()].to_dict()
                     elif self.time_frequency_clustering_method == "maP":
                         parameters = posterior.loc[(posterior["log_likelihood"]+posterior["log_prior"]).idxmax()].to_dict()
                     elif self.time_frequency_clustering_method == "random":
-                        parameters = posterior.sample().to_dict()
+                        parameters = posterior.sample(n=1).iloc[0].to_dict()
                     else:
                         raise NullpolError(f"Unexpected error with time-frequency-clustering-method = {self.time_frequency_clustering_method}. Contact the developers.")
                     # Remove log_likelihood and log_prior from parameters
@@ -302,14 +319,13 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
                     duration=self.duration,
                     start_time=self.start_time
                 )
-                waveform_arguments = self.get_injection_waveform_arguments()
                 logger.info(f"Using waveform arguments: {waveform_arguments}")
-                waveform_generator = self.waveform_generator_class(
+                waveform_generator = waveform_generator_class(
                     duration=self.duration,
                     start_time=self.start_time,
                     sampling_frequency=self.sampling_frequency,
-                    frequency_domain_source_model=self.bilby_frequency_domain_source_model,
-                    parameter_conversion=self.parameter_conversion,
+                    frequency_domain_source_model=frequency_domain_source_model,
+                    parameter_conversion=parameter_conversion,
                     waveform_arguments=waveform_arguments,
                 )
                 ifos.inject_signal(
@@ -334,6 +350,9 @@ class DataGenerationInput(BilbyDataGenerationInput, Input):
                     skypoints=self.time_frequency_clustering_skypoints,
                     return_sky_maximized_spectrogram=True,
                     threshold_type=self.time_frequency_clustering_threshold_type)
+            time_frequency_filter_filename = f"{self.data_directory}/{self.label}_time_frequency_filter.npy"
+            np.save(time_frequency_filter_filename, time_frequency_filter, allow_pickle=False)
+            logger.info(f"Saved time-frequency filter to {time_frequency_filter_filename}.")
             # Generate the cumulative distribution of the spectrogram.
             reversed_cumulative_distribution_fig_fname = f"{self.data_directory}/{self.label}_reversed_cumulative_distribution_of_whitened_energy_pixels.png"
             plot_reverse_cumulative_distribution(spectrogram=sky_maximized_spectrogram,

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/tools/input.py

@@ -192,7 +192,7 @@ class Input(BilbyInput):
 
         Defaults the injection-waveform-approximant to waveform-approximant, if
         no injection-waveform-approximant provided. Note that the default
-        waveform-approximant is `IMRPhenomPv2`.
+        waveform-approximant is `IMRPhenomXPHM`.
         """
         if self.injection_waveform_approximant is None:
             self.injection_waveform_approximant = self.waveform_approximant

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/tools/main.py

@@ -163,7 +163,7 @@ class MainInput(BilbyMainInput, Input):
                 self.check_injection()
 
         self.extra_lines = []
-        self.requirements = []
+        self.requirements = args.requirements
 
     @property
     def analysis_executable(self):

{nullpol-0.1.1 → nullpol-0.1.2}/src/nullpol/tools/parser.py

@@ -131,6 +131,12 @@ def create_nullpol_parser(top_level=True):
     remove_argument(parser, "--epsilon")
     remove_argument(parser, "--default-prior")
     remove_argument(parser, "--version")
+    add_argument_to_group(parser,
+                          "Job submission arguments",
+                          "--requirements",
+                          type=nonestr,
+                          default=None,
+                          help="Additional HTCondor requirements expression.")
     add_argument_to_group(parser,
                           "Likelihood arguments",
                           "--likelihood-type",
@@ -196,8 +202,12 @@ def create_nullpol_parser(top_level=True):
                                 "provide the path to the injection parameters file."))
     clustering_parser.add("--time-frequency-clustering-pe-samples-filename",
                           type=nonestr,
-                          help=("If `maxL`, `maxP` or `random` is chosen in --time-frequency-clustering-method, "
+                          help=("If `maxL`, `maP` or `random` is chosen in --time-frequency-clustering-method, "
                                 "provide the path to the bilby result file."))
+    clustering_parser.add("--time-frequency-filter-file",
+                          type=nonestr,
+                          help=("Path to a previously saved NumPy time-frequency filter. When supplied, it "
+                                "takes precedence over time-frequency-clustering-method."))
     clustering_parser.add('--time-frequency-clustering-threshold',
                           type=float,
                           default=1.0,