"""Unit test for coincident ranking statistic implementations.""" import unittest import numpy as np from utils import parse_args_cpu_only, simple_exit from pycbc.events.stat import statistic_dict # this test only needs to happen on the CPU parse_args_cpu_only('coinc stats') class CoincStatTest(unittest.TestCase): def setUp(self): # one could loop over all single rankings # and detector combinations for a complete test self.single_rank = 'snr' self.detectors = ['H1', 'L1'] # simulate some single-detector triggers from Gaussian noise self.num_trigs = n = 100 self.single_trigs = {} for d in self.detectors: self.single_trigs[d] = { 'snr': np.random.chisquare(2, size=n)**0.5, 'coa_phase': np.random.uniform(0, 2 * np.pi, size=n), 'end_time': 1295441120 + np.random.uniform(-0.01, 0.01, size=n), 'sigmasq': np.random.uniform(1, 10, size=n) } self.time_slide_shift = 0.1
from pycbc.types import TimeSeries, FrequencySeries from pycbc.io.live import SingleCoincForGraceDB from glue.ligolw import ligolw from glue.ligolw import lsctables from glue.ligolw import table from glue.ligolw import utils as ligolw_utils from lal import series as lalseries # if we have the GraceDb module then we can do deeper tests, # otherwise just fall back to quicker ones try: from ligo.gracedb.rest import GraceDb except ImportError: GraceDb = None parse_args_cpu_only("io.live") class ContentHandler(ligolw.LIGOLWContentHandler): pass lsctables.use_in(ContentHandler) class TestIOLive(unittest.TestCase): def setUp(self): self.template = { 'template_id': 0, 'mass1': 10, 'mass2': 11,
"spin1_azimuthal" : (0.0, 2 * numpy.pi), "spin2_a" : (0.0, 1.0), "spin2_polar" : (0, numpy.pi), "spin2_azimuthal" : (0.0, 2 * numpy.pi), "chi_eff" : (-1.0, 1.0), "chi_a" : (0.0, 1.0), "chi_p" : (0.0, 1.0), "phi_s" : (0.0, 2 * numpy.pi), "phi_a" : (0.0, 2 * numpy.pi), "xi1" : (0.0, 1.0), "xi2" : (0.0, 1.0), "chirp_distance" : (2.0, 10.0), } # tests only need to happen on the CPU parse_args_cpu_only("Transforms") class TestTransforms(unittest.TestCase): def setUp(self): # set random seed numpy.random.seed(1024) def test_inverse(self): # set threshold how similar values must be threshold = 0.001 # loop over forward CBC transforms for trans in transforms.common_cbc_forward_transforms:
import tempfile import lal import pycbc from pycbc.types import TimeSeries from pycbc.detector import Detector from pycbc.inject import InjectionSet import unittest import numpy import itertools from glue.ligolw import ligolw from glue.ligolw import lsctables from glue.ligolw import utils from utils import parse_args_cpu_only, simple_exit # Injection tests only need to happen on the CPU parse_args_cpu_only("Injections") class MyInjection(object): def fill_sim_inspiral_row(self, row): # using dummy values for many fields, should work for our purposes row.waveform = 'TaylorT4' row.distance = self.distance total_mass = self.mass1 + self.mass2 row.mass1 = self.mass1 row.mass2 = self.mass2 row.eta = self.mass1 * self.mass2 / total_mass ** 2 row.mchirp = total_mass * row.eta ** (3. / 5.) row.latitude = self.latitude row.longitude = self.longitude row.inclination = self.inclination row.polarization = self.polarization
import pycbc.psd import pycbc.pnutils from pycbc import pnutils from pycbc.types import Array import difflib import sys import matplotlib matplotlib.use('Agg') import pylab import unittest from utils import parse_args_cpu_only, simple_exit # This will return whatever is appropriate, depending on whether this # particular instance of the unittest was called for CPU, CUDA, or OpenCL parse_args_cpu_only("Template bank module") import argparse parser = argparse.ArgumentParser() def update_mass_parameters(tmpltbank_class): """ Choose various sets of mass parameters for testing. """ num_comp_masses = 3 min_mass1 = [1,2,6] max_mass1 = [5,8,12] min_mass2 = [1,1,1] max_mass2 = [5,5,5] num_tot_masses = 3 # These *must* be provided
import pycbc.psd import pycbc.pnutils from pycbc import pnutils from pycbc.types import Array import difflib import sys import matplotlib matplotlib.use('Agg') import pylab import unittest from utils import parse_args_cpu_only, simple_exit # This will return whatever is appropriate, depending on whether this # particular instance of the unittest was called for CPU, CUDA, or OpenCL parse_args_cpu_only("Template bank module") import argparse parser = argparse.ArgumentParser() def update_mass_parameters(tmpltbank_class): """ Choose various sets of mass parameters for testing. """ num_comp_masses = 3 min_mass1 = [1, 2, 6] max_mass1 = [5, 8, 12] min_mass2 = [1, 1, 1] max_mass2 = [5, 5, 5] num_tot_masses = 3
"spin1_azimuthal": (0.0, 2 * numpy.pi), "spin2_a": (0.0, 1.0), "spin2_polar": (0, numpy.pi), "spin2_azimuthal": (0.0, 2 * numpy.pi), "chi_eff": (-1.0, 1.0), "chi_a": (0.0, 1.0), "chi_p": (0.0, 1.0), "phi_s": (0.0, 2 * numpy.pi), "phi_a": (0.0, 2 * numpy.pi), "xi1": (0.0, 1.0), "xi2": (0.0, 1.0), "chirp_distance": (2.0, 10.0), } # tests only need to happen on the CPU parse_args_cpu_only("Transforms") class TestTransforms(unittest.TestCase): def setUp(self): # set random seed numpy.random.seed(1024) def test_inverse(self): # set threshold how similar values must be threshold = 0.001 # loop over forward CBC transforms for trans in transforms.common_cbc_forward_transforms:
import unittest from pycbc import distributions from pycbc.inference import entropy from utils import parse_args_cpu_only from utils import simple_exit from pycbc.workflow import WorkflowConfigParser # distributions to exclude from one-dimensional distribution unit tests # some of these distributons have their own specific unit test EXCLUDE_DIST_NAMES = [ "fromfile", "arbitrary", "external", "uniform_solidangle", "uniform_sky", "independent_chip_chieff", "uniform_f0_tau" ] # tests only need to happen on the CPU parse_args_cpu_only("Distributions") def cartesian(arrays): """ Returns a cartesian product from a list of iterables. """ return numpy.array( [numpy.array(element) for element in itertools.product(*arrays)]) class TestDistributions(unittest.TestCase): def setUp(self): # set random seed numpy.random.seed(1024)
# """ These are the unittests for the pycbc.inference subpackage """ import sys import pycbc import unittest import numpy from pycbc import distributions from pycbc import inference from pycbc import waveform from pycbc import psd as pypsd from utils import parse_args_cpu_only, simple_exit # tests only need to happen on the CPU parse_args_cpu_only("Inference") class TestInference(unittest.TestCase): def setUp(self, *args): numpy.random.seed(1024) def test_likelihood_evaluator_init(self): # data args seglen = 4 sample_rate = 2048 N = seglen * sample_rate/2 + 1 fmin = 30. # setup waveform generator and signal parameters m1, m2, s1z, s2z, tsig = 38.6, 29.3, 0., 0., 3.1
# # ============================================================================= # """ These are the unit-tests for the pycbc.fft subpackage, testing only unthreaded backends for the various schemes. """ import pycbc.fft from pycbc.scheme import CPUScheme import unittest from sys import exit as _exit from utils import parse_args_cpu_only, simple_exit from fft_base import _BaseTestFFTClass parse_args_cpu_only("FFTW openmp backend") # See if we can get set the FFTW backend to 'openmp'; if not, say so and exit. if 'fftw' in pycbc.fft.get_backend_names(): import pycbc.fft.fftw try: pycbc.fft.fftw.set_threads_backend('openmp') except: print( "Unable to import openmp threads backend to FFTW; skipping openmp thread tests" ) _exit(0) else: print( "FFTW does not seem to be an available CPU backend; skipping openmp thread tests"
# ''' These are the unittests for the pycbc frame/cache reading functions ''' import pycbc import unittest import pycbc.frame import numpy import lal from pycbc.types import TimeSeries from utils import parse_args_cpu_only, simple_exit # Frame tests only need to happen on the CPU parse_args_cpu_only("Frame I/O") class FrameTestBase(unittest.TestCase): def setUp(self): numpy.random.seed(1023) self.size = pow(2,12) self.data1 = numpy.array(numpy.random.rand(self.size), dtype=self.dtype) self.data2 = numpy.array(numpy.random.rand(self.size), dtype=self.dtype) # If the dtype is complex, we should throw in some complex values as well if self.dtype == numpy.complex64 or self.dtype == numpy.complex128: self.data1 += numpy.random.rand(self.size) * 1j self.data2 += numpy.random.rand(self.size) * 1j self.delta_t = .5
# Preamble # # ============================================================================= # """ These are the unittests for the pycbc.filter.matchedfilter module """ import sys import unittest import numpy from pycbc.pnutils import * from pycbc.scheme import * from utils import parse_args_cpu_only, simple_exit # We only need CPU tests parse_args_cpu_only("PN Utilities") class TestUtils(unittest.TestCase): def test_mass1_mass2_to_tau0_tau3(self): result = mass1_mass2_to_tau0_tau3(3.0,5.0,15.0) answer = (63.039052988077955, 2.353532999897545) self.assertAlmostEqual(result[0]/answer[0],1,places=6) self.assertAlmostEqual(result[1]/answer[1],1,places=6) def test_tau0_tau3_to_mtotal_eta(self): result = tau0_tau3_to_mtotal_eta(93.84928959285253,2.9198487498891126,20.0) answer = [5., 4.*1./5./5.] self.assertAlmostEqual(result[0]/answer[0],1,places=6) self.assertAlmostEqual(result[1]/answer[1],1,places=6) def test_tau0_tau3_to_mass1_mass2(self):
''' These are the unittests for the pycbc frame/cache reading functions ''' import pycbc import unittest from pycbc.types import * from pycbc.scheme import * import pycbc.frame import numpy import lal #from pylal import Fr from utils import parse_args_cpu_only, simple_exit # Frame tests only need to happen on the CPU parse_args_cpu_only("Frame I/O") class FrameTestBase(unittest.TestCase): def setUp(self): numpy.random.seed(1023) self.size = pow(2, 12) self.data1 = numpy.array(numpy.random.rand(self.size), dtype=self.dtype) self.data2 = numpy.array(numpy.random.rand(self.size), dtype=self.dtype) # If the dtype is complex, we should throw in some complex values as well if self.dtype == numpy.complex64 or self.dtype == numpy.complex128: self.data1 += numpy.random.rand(self.size) * 1j
These are the unittests for samplers in the pycbc.inference subpackage. """ import sys import pycbc import unittest import numpy from pycbc import distributions from pycbc.inference import likelihood from pycbc.inference import sampler from pycbc.psd import analytical from pycbc.waveform import generator from utils import parse_args_cpu_only from utils import simple_exit # tests only need to happen on the CPU parse_args_cpu_only("Samplers") class TestSamplers(unittest.TestCase): def setUp(self, *args): # set random seed numpy.random.seed(1024) # set data parameters self.ifos = ["H1", "L1", "V1"] self.data_length = 4 # in seconds self.sample_rate = 2048 # in Hertz self.fdomain_samples = self.data_length * self.sample_rate / 2 + 1 self.delta_f = 1.0 / self.data_length self.fmin = {ifo : 30.0 for ifo in self.ifos}
from pycbc.types import TimeSeries, FrequencySeries from pycbc.io.live import SingleCoincForGraceDB from glue.ligolw import ligolw from glue.ligolw import lsctables from glue.ligolw import table from glue.ligolw import utils as ligolw_utils # if we have the GraceDb module then we can do deeper tests, # otherwise just fall back to quicker ones try: from ligo.gracedb.rest import GraceDb except ImportError: GraceDb = None parse_args_cpu_only("io.live") class ContentHandler(ligolw.LIGOLWContentHandler): pass lsctables.use_in(ContentHandler) class TestIOLive(unittest.TestCase): def setUp(self): self.template = {'template_id': 0, 'mass1': 10, 'mass2': 11, 'spin1x': 0, 'spin1y': 0, 'spin1z': 0, 'spin2x': 0, 'spin2y': 0,
import tempfile import lal import pycbc from pycbc.types import TimeSeries from pycbc.detector import Detector, get_available_detectors from pycbc.inject import InjectionSet import unittest import numpy import itertools from glue.ligolw import ligolw from glue.ligolw import lsctables from glue.ligolw import utils as ligolw_utils from utils import parse_args_cpu_only, simple_exit # Injection tests only need to happen on the CPU parse_args_cpu_only("Injections") class MyInjection(object): def fill_sim_inspiral_row(self, row): # using dummy values for many fields, should work for our purposes row.waveform = 'TaylorT4threePointFivePN' row.distance = self.distance total_mass = self.mass1 + self.mass2 row.mass1 = self.mass1 row.mass2 = self.mass2 row.eta = self.mass1 * self.mass2 / total_mass**2 row.mchirp = total_mass * row.eta**(3. / 5.) row.latitude = self.latitude row.longitude = self.longitude row.inclination = self.inclination
# # ============================================================================= # """ These are the unit-tests for the pycbc.fft subpackage, testing only unthreaded backends for the various schemes. """ import pycbc.fft from pycbc.scheme import CPUScheme import unittest from sys import exit as _exit from utils import parse_args_cpu_only, simple_exit from fft_base import _BaseTestFFTClass parse_args_cpu_only("FFTW openmp backend") # See if we can get set the FFTW backend to 'openmp'; if not, say so and exit. if 'fftw' in pycbc.fft.get_backend_names(): import pycbc.fft.fftw try: pycbc.fft.fftw.set_threads_backend('openmp') except: print "Unable to import openmp threads backend to FFTW; skipping openmp thread tests" _exit(0) else: print "FFTW does not seem to be an available CPU backend; skipping openmp thread tests" _exit(0) # Now set the number of threads to something nontrivial
# ============================================================================= # """ These are the unit-tests for the pycbc.fft subpackage, testing only unthreaded backends for the various schemes. """ import platform import unittest import pycbc.fft from pycbc.scheme import CPUScheme from sys import exit as _exit from utils import parse_args_cpu_only, simple_exit from fft_base import _BaseTestFFTClass parse_args_cpu_only("MKL threaded backend") # See if we can get set the FFTW backend to 'openmp'; if not, say so and exit. if 'arm64' in platform.machine(): print("MKL not supported on arm64, skipping") pass elif not 'mkl' in pycbc.fft.get_backend_names(): print("MKL does not seem to be available; why isn't it installed?") _exit(0) else: # Now set the number of threads to something nontrivial # Most of the work is now done in fft_base. FFTTestClasses = [] for num_threads in [2, 4, 6, 8]:
# # ============================================================================= # """ These are the unit-tests for the pycbc.fft.fftw subpackage, testing only the pthreads threading backend. """ import pycbc.fft from pycbc.scheme import CPUScheme import unittest from sys import exit as _exit from utils import parse_args_cpu_only, simple_exit from fft_base import _BaseTestFFTClass parse_args_cpu_only("FFTW pthreads backend") # See if we can get set the FFTW backend to 'pthreads'; if not, say so and exit. if 'fftw' in pycbc.fft._all_backends_list: import pycbc.fft.fftw try: pycbc.fft.fftw.set_threads_backend('pthreads') except: print "Unable to import pthreads threads backend to FFTW; skipping pthreads thread tests" _exit(0) else: print "FFTW does not seem to be an available CPU backend; skipping pthreads thread tests" _exit(0) # Most of the work is now done in fft_base.
# # Preamble # # ============================================================================= # """ These are the unittests for the pycbc.filter.matchedfilter module """ import unittest import numpy from pycbc.pnutils import * from pycbc.scheme import * from utils import parse_args_cpu_only, simple_exit # We only need CPU tests parse_args_cpu_only("PN Utilities") class TestUtils(unittest.TestCase): def test_mass1_mass2_to_tau0_tau3(self): result = mass1_mass2_to_tau0_tau3(3.0, 5.0, 15.0) answer = (63.039052988077955, 2.353532999897545) self.assertAlmostEqual(result[0] / answer[0], 1, places=6) self.assertAlmostEqual(result[1] / answer[1], 1, places=6) def test_tau0_tau3_to_mtotal_eta(self): result = tau0_tau3_to_mtotal_eta(93.84928959285253, 2.9198487498891126, 20.0) answer = [5., 4. * 1. / 5. / 5.] self.assertAlmostEqual(result[0] / answer[0], 1, places=6) self.assertAlmostEqual(result[1] / answer[1], 1, places=6)
# # ============================================================================= # """ These are the unittests for the pycbc.inference subpackage """ import sys import pycbc import unittest import numpy from pycbc import inference, waveform from pycbc import psd as pypsd from utils import parse_args_cpu_only, simple_exit # tests only need to happen on the CPU parse_args_cpu_only("Inference") class TestInference(unittest.TestCase): def setUp(self, *args): numpy.random.seed(1024) def test_likelihood_evaluator_init(self): # data args seglen = 4 sample_rate = 2048 N = seglen * sample_rate / 2 + 1 fmin = 30. # setup waveform generator and signal parameters
import unittest from pycbc import distributions from pycbc.inference import entropy from utils import parse_args_cpu_only from utils import simple_exit from pycbc.workflow import WorkflowConfigParser # distributions to exclude from one-dimensional distribution unit tests # some of these distributons have their own specific unit test EXCLUDE_DIST_NAMES = ["fromfile", "arbitrary", "uniform_solidangle", "uniform_sky", "independent_chip_chieff", "uniform_component_masses"] # tests only need to happen on the CPU parse_args_cpu_only("Distributions") def cartesian(arrays): """ Returns a cartesian product from a list of iterables. """ return numpy.array([numpy.array(element) for element in itertools.product(*arrays)]) class TestDistributions(unittest.TestCase): def setUp(self): # set random seed numpy.random.seed(1024) # path to example configuration file for testing
These are the unittests for samplers in the pycbc.inference subpackage. """ import sys import pycbc import unittest import numpy from pycbc import distributions from pycbc.inference import likelihood from pycbc.inference import sampler from pycbc.psd import analytical from pycbc.waveform import generator from utils import parse_args_cpu_only from utils import simple_exit # tests only need to happen on the CPU parse_args_cpu_only("Samplers") class TestSamplers(unittest.TestCase): def setUp(self, *args): # set random seed numpy.random.seed(1024) # set data parameters self.ifos = ["H1", "L1", "V1"] self.data_length = 4 # in seconds self.sample_rate = 2048 # in Hertz self.fdomain_samples = self.data_length * self.sample_rate / 2 + 1 self.delta_f = 1.0 / self.data_length self.fmin = 30.0