Minor adjust to the ROQ weight generation

1. Convert the light travel time explicitly calculated value: uses 1.1 * R_earth / c (i.e. 10% more than the expected maximum)
2. Use a single fixed time_space: previously, the time resolution was set, then recalculated from the difference in the first two elements of time_samples. This could lead to buggy behaviour since that is no longer an evenly spaced array after the subtraction from the start time is made.
3. Add info statements
4. Adds a check if the seglen is shorter than the duration
5. Apply a safety factor of 5 to ensure the time step is short enough. This will increase the size of the ROQ array basis by ~ a factor of 5, but in testing I found it helped remove bias from examples just searching over RA, DEC, and geocent_time.
6. Add explicit clean up of memory

Closes #372 (closed)

bilby/gw/likelihood.py

 from __future__ import division
 
+import gc
 import os
 import json
 import copy
@@ -843,7 +844,7 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
 
         dt = interferometer.time_delay_from_geocenter(
             self.parameters['ra'], self.parameters['dec'],
-            interferometer.strain_data.start_time)
+            self.parameters['geocent_time'])
         ifo_time = self.parameters['geocent_time'] + dt - \
             interferometer.strain_data.start_time
 
@@ -864,6 +865,7 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
         indices, in_bounds = self._closest_time_indices(
             ifo_time, self.weights['time_samples'])
         if not in_bounds:
+            logger.debug("SNR calculation error: requested time at edge of ROQ time samples")
             return self._CalculatedSNRs(
                 d_inner_h=np.nan_to_num(-np.inf), optimal_snr_squared=0,
                 complex_matched_filter_snr=np.nan_to_num(-np.inf),
@@ -875,7 +877,7 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
 
         d_inner_h = interp1d(
             self.weights['time_samples'][indices],
-            d_inner_h_tc_array, kind='cubic')(ifo_time)
+            d_inner_h_tc_array, kind='cubic', assume_sorted=True)(ifo_time)
 
         optimal_snr_squared = \
             np.vdot(np.abs(h_plus_quadratic + h_cross_quadratic)**2,
@@ -923,7 +925,7 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
 
         """
 
-        earth_light_crossing_time = radius_of_earth / speed_of_light
+        earth_light_crossing_time = 2 * radius_of_earth / speed_of_light
         time_space = self._get_time_resolution()
         delta_times = np.arange(
             self.priors['geocent_time'].minimum - earth_light_crossing_time,
@@ -938,14 +940,14 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
                 if ifo.maximum_frequency > self.roq_params['fhigh']:
                     raise ValueError("Requested maximum frequency larger than ROQ basis fhigh")
                 # Generate frequencies for the ROQ
-                roq_frequencies = np.arange(
-                    self.roq_params['flow'],
-                    self.roq_params['fhigh'] + 1,
-                    1 / self.roq_params['seglen'])
+                roq_frequencies = create_frequency_series(
+                    sampling_frequency=self.roq_params['fhigh'] * 2,
+                    duration=self.roq_params['seglen'])
+                roq_mask = roq_frequencies >= self.roq_params['flow']
+                roq_frequencies = roq_frequencies[roq_mask]
                 overlap_frequencies, ifo_idxs, roq_idxs = np.intersect1d(
                     ifo.frequency_array[ifo.frequency_mask], roq_frequencies,
                     return_indices=True)
-
             else:
                 overlap_frequencies = ifo.frequency_array[ifo.frequency_mask]
                 roq_idxs = np.arange(linear_matrix.shape[0], dtype=int)
@@ -960,21 +962,9 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
                     ifo.name, len(overlap_frequencies),
                     min(overlap_frequencies), max(overlap_frequencies)))
 
-            # array to be filled with data, shifted by discrete time_samples
-            tc_shifted_data = np.zeros([
-                len(self.weights['time_samples']), len(overlap_frequencies)],
-                dtype=complex)
-
-            # shift data to beginning of the prior increment by the time step
-            shifted_data =\
-                ifo.frequency_domain_strain[ifo.frequency_mask][ifo_idxs] * \
-                np.exp(2j * np.pi * overlap_frequencies *
-                       self.weights['time_samples'][0])
-            single_time_shift = np.exp(
-                2j * np.pi * overlap_frequencies * time_space)
-            for j in range(len(self.weights['time_samples'])):
-                tc_shifted_data[j] = shifted_data
-                shifted_data *= single_time_shift
+            data = ifo.frequency_domain_strain[ifo.frequency_mask][ifo_idxs]
+            tc_shifted_data = data * np.exp(
+                2j * np.pi * overlap_frequencies * time_samples[:, np.newaxis])
 
             # to not kill all computers this minimises the memory usage of the
             # required inner products
@@ -987,7 +977,8 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
                 linear_matrix[roq_idxs],
                 max_elements) * 4 / ifo.strain_data.duration
 
-            del tc_shifted_data
+            del tc_shifted_data, overlap_frequencies
+            gc.collect()
 
             self.weights[ifo.name + '_quadratic'] = build_roq_weights(
                 1 /