Merge branch 'master' into 'calibration'

# Conflicts:
#   tupak/core/prior.py
#   tupak/gw/__init__.py

CHANGELOG.md

@@ -4,6 +4,13 @@
 
 Changes currently on master, but not under a tag.
 
+### Changes
+- The paths between imports where changed so that calls such as
+  `tupak.WaveformGenerator` no longer work. Instead, we need to use
+  `tupak.gw.WaveformGenerator`. This was done to keep things cleaner going
+  forward (when, for example, there may be multiple wfg's).
+
+
 ## [0.2.1] 2018-07-18
 
 ### Added

examples/injection_examples/basic_tutorial.py

@@ -36,11 +36,10 @@ waveform_arguments = dict(waveform_approximant='IMRPhenomPv2',
                           reference_frequency=50.)
 
 # Create the waveform_generator using a LAL BinaryBlackHole source function
-waveform_generator = tupak.WaveformGenerator(duration=duration,
-                                             sampling_frequency=sampling_frequency,
-                                             frequency_domain_source_model=tupak.gw.source.lal_binary_black_hole,
-                                             parameters=injection_parameters,
-                                             waveform_arguments=waveform_arguments)
+waveform_generator = tupak.gw.WaveformGenerator(
+    duration=duration, sampling_frequency=sampling_frequency,
+    frequency_domain_source_model=tupak.gw.source.lal_binary_black_hole,
+    parameters=injection_parameters, waveform_arguments=waveform_arguments)
 hf_signal = waveform_generator.frequency_domain_strain()
 
 # Set up interferometers.  In this case we'll use three interferometers (LIGO-Hanford (H1), LIGO-Livingston (L1),

examples/injection_examples/how_to_specify_the_prior.py

@@ -23,11 +23,10 @@ waveform_arguments = dict(waveform_approximant='IMRPhenomPv2',
                           reference_frequency=50.)
 
 # Create the waveform_generator using a LAL BinaryBlackHole source function
-waveform_generator = tupak.WaveformGenerator(duration=duration,
-                                             sampling_frequency=sampling_frequency,
-                                             frequency_domain_source_model=tupak.gw.source.lal_binary_black_hole,
-                                             parameters=injection_parameters,
-                                             waveform_arguments=waveform_arguments)
+waveform_generator = tupak.gw.WaveformGenerator(
+    duration=duration, sampling_frequency=sampling_frequency,
+    frequency_domain_source_model=tupak.gw.source.lal_binary_black_hole,
+    parameters=injection_parameters, waveform_arguments=waveform_arguments)
 hf_signal = waveform_generator.frequency_domain_strain()
 
 # Set up interferometers.

examples/injection_examples/marginalized_likelihood.py

@@ -22,7 +22,7 @@ waveform_arguments = dict(waveform_approximant='IMRPhenomPv2',
                           reference_frequency=50.)
 
 # Create the waveform_generator using a LAL BinaryBlackHole source function
-waveform_generator = tupak.WaveformGenerator(
+waveform_generator = tupak.gw.WaveformGenerator(
     duration=duration, sampling_frequency=sampling_frequency,
     frequency_domain_source_model=tupak.gw.source.lal_binary_black_hole, parameters=injection_parameters,
     waveform_arguments=waveform_arguments)
@@ -42,7 +42,7 @@ for key in ['a_1', 'a_2', 'tilt_1', 'tilt_2', 'phi_12', 'phi_jl', 'iota', 'ra',
 # Initialise GravitationalWaveTransient
 # Note that we now need to pass the: priors and flags for each thing that's being marginalised.
 # This is still under development so care should be taken with the marginalised likelihood.
-likelihood = tupak.GravitationalWaveTransient(
+likelihood = tupak.gw.GravitationalWaveTransient(
     interferometers=IFOs, waveform_generator=waveform_generator, prior=priors,
     distance_marginalization=True, phase_marginalization=False)
 

test/conversion_tests.py

@@ -26,39 +26,39 @@ class TestBasicConversions(unittest.TestCase):
         del self.symmetric_mass_ratio
 
     def test_total_mass_and_mass_ratio_to_component_masses(self):
-        mass_1, mass_2 = tupak.conversion.total_mass_and_mass_ratio_to_component_masses(self.mass_ratio, self.total_mass)
+        mass_1, mass_2 = tupak.gw.conversion.total_mass_and_mass_ratio_to_component_masses(self.mass_ratio, self.total_mass)
         self.assertTupleEqual((mass_1, mass_2), (self.mass_1, self.mass_2))
 
     def test_symmetric_mass_ratio_to_mass_ratio(self):
-        mass_ratio = tupak.conversion.symmetric_mass_ratio_to_mass_ratio(self.symmetric_mass_ratio)
+        mass_ratio = tupak.gw.conversion.symmetric_mass_ratio_to_mass_ratio(self.symmetric_mass_ratio)
         self.assertAlmostEqual(self.mass_ratio, mass_ratio)
 
     def test_chirp_mass_and_total_mass_to_symmetric_mass_ratio(self):
-        symmetric_mass_ratio = tupak.conversion.chirp_mass_and_total_mass_to_symmetric_mass_ratio(self.chirp_mass, self.total_mass)
+        symmetric_mass_ratio = tupak.gw.conversion.chirp_mass_and_total_mass_to_symmetric_mass_ratio(self.chirp_mass, self.total_mass)
         self.assertAlmostEqual(self.symmetric_mass_ratio, symmetric_mass_ratio)
 
     def test_chirp_mass_and_mass_ratio_to_total_mass(self):
-        total_mass = tupak.conversion.chirp_mass_and_mass_ratio_to_total_mass(self.chirp_mass, self.mass_ratio)
+        total_mass = tupak.gw.conversion.chirp_mass_and_mass_ratio_to_total_mass(self.chirp_mass, self.mass_ratio)
         self.assertAlmostEqual(self.total_mass, total_mass)
 
     def test_component_masses_to_chirp_mass(self):
-        chirp_mass = tupak.conversion.component_masses_to_chirp_mass(self.mass_1, self.mass_2)
+        chirp_mass = tupak.gw.conversion.component_masses_to_chirp_mass(self.mass_1, self.mass_2)
         self.assertAlmostEqual(self.chirp_mass, chirp_mass)
 
     def test_component_masses_to_total_mass(self):
-        total_mass = tupak.conversion.component_masses_to_total_mass(self.mass_1, self.mass_2)
+        total_mass = tupak.gw.conversion.component_masses_to_total_mass(self.mass_1, self.mass_2)
         self.assertAlmostEqual(self.total_mass, total_mass)
 
     def test_component_masses_to_symmetric_mass_ratio(self):
-        symmetric_mass_ratio = tupak.conversion.component_masses_to_symmetric_mass_ratio(self.mass_1, self.mass_2)
+        symmetric_mass_ratio = tupak.gw.conversion.component_masses_to_symmetric_mass_ratio(self.mass_1, self.mass_2)
         self.assertAlmostEqual(self.symmetric_mass_ratio, symmetric_mass_ratio)
 
     def test_component_masses_to_mass_ratio(self):
-        mass_ratio = tupak.conversion.component_masses_to_mass_ratio(self.mass_1, self.mass_2)
+        mass_ratio = tupak.gw.conversion.component_masses_to_mass_ratio(self.mass_1, self.mass_2)
         self.assertAlmostEqual(self.mass_ratio, mass_ratio)
 
     def test_mass_1_and_chirp_mass_to_mass_ratio(self):
-        mass_ratio = tupak.conversion.mass_1_and_chirp_mass_to_mass_ratio(self.mass_1, self.chirp_mass)
+        mass_ratio = tupak.gw.conversion.mass_1_and_chirp_mass_to_mass_ratio(self.mass_1, self.chirp_mass)
         self.assertAlmostEqual(self.mass_ratio, mass_ratio)
 
 
@@ -92,4 +92,4 @@ class TestConvertToLALBBHParams(unittest.TestCase):
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()

test/sampler_tests.py

@@ -35,7 +35,6 @@ class TestSampler(unittest.TestCase):
             outdir=test_directory, use_ratio=False)
 
     def tearDown(self):
-        os.rmdir(self.sampler.outdir)
         del self.sampler
 
     def test_search_parameter_keys(self):
@@ -88,9 +87,6 @@ class TestSampler(unittest.TestCase):
         print(expected_result.__dict__)
         self.assertDictEqual(self.sampler.result.__dict__, expected_result.__dict__)
 
-    def test_make_outdir_if_no_outdir_exists(self):
-        self.assertTrue(os.path.isdir(self.sampler.outdir))
-
     def test_prior_transform_transforms_search_parameter_keys(self):
         self.sampler.prior_transform([0])
         expected_prior = prior.Uniform(0, 1)

tupak/__init__.py

@@ -18,14 +18,10 @@ https://monash.docs.ligo.org/tupak/installation.html.
 
 from __future__ import print_function, division, absolute_import
 
-# import local files, core utils should be imported first
-from tupak.core import utils, likelihood, prior, result, sampler
-from tupak.gw import detector, conversion, source, waveform_generator
-from tupak.hyper import likelihood, model
+import tupak.core
+import tupak.gw
+import tupak.hyper
 
-# import a few often-used functions and classes to simplify scripts
-from tupak.core.likelihood import Likelihood
-from tupak.gw.likelihood import GravitationalWaveTransient
-from tupak.gw.waveform_generator import WaveformGenerator
+from tupak.core import utils, likelihood, prior, result, sampler
 from tupak.core.sampler import run_sampler
-from tupak.hyper.likelihood import HyperparameterLikelihood
+from tupak.core.likelihood import Likelihood

tupak/core/prior.py

@@ -9,6 +9,7 @@ import scipy.stats
 import os
 
 from tupak.core.utils import logger
+from tupak.core import utils
 
 
 class PriorSet(dict):
@@ -39,6 +40,7 @@ class PriorSet(dict):
             Output file naming scheme
         """
 
+        utils.check_directory_exists_and_if_not_mkdir(outdir)
         prior_file = os.path.join(outdir, "{}.prior".format(label))
         logger.debug("Writing priors to {}".format(prior_file))
         with open(prior_file, "w") as outfile:

tupak/core/result.py

@@ -161,8 +161,7 @@ class Result(dict):
     def save_to_file(self):
         """ Writes the Result to a deepdish h5 file """
         file_name = result_file_name(self.outdir, self.label)
-        if os.path.isdir(self.outdir) is False:
-            os.makedirs(self.outdir)
+        utils.check_directory_exists_and_if_not_mkdir(self.outdir)
         if os.path.isfile(file_name):
             logger.debug(
                 'Renaming existing file {} to {}.old'.format(file_name,
@@ -307,6 +306,7 @@ class Result(dict):
         fig = corner.corner(xs, **kwargs)
 
         if save:
+            utils.check_directory_exists_and_if_not_mkdir(self.outdir)
             filename = '{}/{}_corner.png'.format(self.outdir, self.label)
             logger.debug('Saving corner plot to {}'.format(filename))
             fig.savefig(filename, dpi=dpi)
@@ -339,6 +339,7 @@ class Result(dict):
         fig.tight_layout()
         filename = '{}/{}_walkers.png'.format(self.outdir, self.label)
         logger.debug('Saving walkers plot to {}'.format('filename'))
+        utils.check_directory_exists_and_if_not_mkdir(self.outdir)
         fig.savefig(filename)
 
     def samples_to_posterior(self, likelihood=None, priors=None,

tupak/core/sampler.py

@@ -97,9 +97,6 @@ class Sampler(object):
 
         self._log_summary_for_sampler()
 
-        if os.path.isdir(outdir) is False:
-            os.makedirs(outdir)
-
         self.result = self._initialise_result()
 
     @property
@@ -1013,7 +1010,6 @@ def run_sampler(likelihood, priors=None, label='label', outdir='outdir',
     priors.fill_priors(likelihood, default_priors_file=default_priors_file)
 
     if save:
-        utils.check_directory_exists_and_if_not_mkdir(outdir)
         priors.write_to_file(outdir, label)
 
     if implemented_samplers.__contains__(sampler.title()):

tupak/gw/__init__.py

@@ -7,3 +7,7 @@ import tupak.gw.source
 import tupak.gw.utils
 import tupak.gw.waveform_generator
 from . import calibration
+
+
+from tupak.gw.waveform_generator import WaveformGenerator
+from tupak.gw.likelihood import GravitationalWaveTransient