Basis chisq - test

bin/inference/pycbc_inference_plot_posterior

@@ -143,7 +143,7 @@ if opts.plot_prior is not None:
         for func, param in fp.attrs['remapped_params']:
             try:
                 remapped_params[param] = prior_samples[func]
-            except (NameError, TypeError):
+            except (NameError, TypeError, AttributeError):
                 continue
         prior_samples = FieldArray.from_kwargs(**remapped_params)
         for param in fp.attrs['static_params']:
@@ -184,7 +184,7 @@ if opts.plot_injection_parameters:
     for p in parameters:
         try:
             vals = injections[p]
-        except (NameError, TypeError):
+        except (NameError, TypeError, AttributeError):
             # injection doesn't have this parameter, skip
             logging.warn("Could not find injection parameter {}".format(p))
             continue

bin/plotting/pycbc_plot_range

@@ -64,7 +64,6 @@ for psd_file in args.psd_files:
         pylab.errorbar((start+end)/2, ranges[wf_key], xerr=(end-start)/2,
                        ecolor=pycbc.results.ifo_color(ifo), label=label,
                        fmt='none')
-
 pylab.legend(loc="best", fontsize='small')
 
 if len(args.approximant) == 1:

bin/pycbc_inspiral

@@ -23,6 +23,7 @@ import pycbc
 import pycbc.version
 from pycbc import vetoes, psd, waveform, strain, scheme, fft, DYN_RANGE_FAC, events
 from pycbc.vetoes.sgchisq import SingleDetSGChisq
+from pycbc.vetoes.basischisq import SingleDetHMChisq, SingleDetCombinedChisq
 from pycbc.filter import MatchedFilterControl, make_frequency_series, qtransform
 from pycbc.types import TimeSeries, FrequencySeries, zeros, float32, complex64
 import pycbc.version
@@ -207,6 +208,8 @@ fft.insert_fft_option_group(parser)
 pycbc.opt.insert_optimization_option_group(parser)
 pycbc.inject.insert_injfilterrejector_option_group(parser)
 SingleDetSGChisq.insert_option_group(parser)
+SingleDetHMChisq.insert_option_group(parser)
+SingleDetCombinedChisq.insert_option_group(parser)
 opt = parser.parse_args()
 
 # Check that the values returned for the options make sense
@@ -267,6 +270,8 @@ with ctx:
         'psd_var_val'    : float32,
                 }
     out_types.update(SingleDetSGChisq.returns)
+    out_types.update(SingleDetHMChisq.returns)
+    out_types.update(SingleDetCombinedChisq.returns)
     out_vals = {key: None for key in out_types}
     names = sorted(out_vals.keys())
 
@@ -371,6 +376,29 @@ with ctx:
 
     sg_chisq = SingleDetSGChisq.from_cli(opt, bank, opt.chisq_bins)
 
+    hm_chisq = SingleDetHMChisq.from_cli(opt)
+
+    combined_chisq = SingleDetCombinedChisq.from_cli(opt)
+
+    # create scratch space for modes
+    if hm_chisq.do or combined_chisq.do:
+        approxs = numpy.unique(bank.table.approximant)
+        modesmem_cache = {}
+        for apprx in approxs:
+            # check that we can
+            try:
+                modes = waveform.hm_approximants[apprx]
+            except KeyError:
+                raise ValueError("cannot generate individual modes for "
+                                 "approximant {}".format(apprx))
+            modemem = {mode: template_mem.copy() for mode in modes}
+            modesmem_cache[apprx] = modemem
+        # whiten data
+        wh_segments = [seg * seg.psd**0.5 for seg in segments]
+    else:
+        wh_segments = [None]*len(segments)
+        modesmem_cache = {}
+
     ntemplates = len(bank)
     nfilters = 0
 
@@ -390,6 +418,14 @@ with ctx:
         t_num += tnum_start
         tmplt_generated = False
 
+        # Turn on individual modes generation if calculating HM Chisq
+        if hm_chisq.do:
+            apprx = bank.table.approximant[t_num]
+            bank.modes_out = modesmem_cache[apprx]
+            bank.generate_modes = bank.modes_out.keys()
+        else:
+            bank.generate_modes = None
+
         for s_num, stilde in enumerate(segments):
             # Filter check checks the 'inj_filter_rejector' options to
             # determine whether
@@ -439,6 +475,18 @@ with ctx:
                                           out_vals['chisq_dof'],
                                           idx+stilde.analyze.start)
 
+            out_vals['hm_chisq'], out_vals['hm_chisq_dof'] = \
+                hm_chisq.values(template, wh_segments[s_num], stilde.psd,
+                                norm*snrv,
+                                idx+stilde.analyze.start,
+                                data_whitening='whitened')
+
+            out_vals['combined_chisq'], out_vals['combined_chisq_dof'] = \
+                combined_chisq.values(template, wh_segments[s_num], stilde.psd,
+                                norm*snrv,
+                                idx+stilde.analyze.start,
+                                data_whitening='whitened')
+
             out_vals['cont_chisq'] = \
                   autochisq.values(snr, idx+stilde.analyze.start, template,
                                    stilde.psd, norm, stilde=stilde,

pycbc/conversions.py

@@ -1215,10 +1215,10 @@ def get_final_from_initial(mass1, mass2, spin1x=0., spin1y=0., spin1z=0.,
     final_mass = numpy.zeros(mass1.shape)
     final_spin = numpy.zeros(mass1.shape)
     for ii in range(final_mass.size):
-        m1 = mass1[ii]
-        m2 = mass2[ii]
-        spin1 = [spin1x[ii], spin1y[ii], spin1z[ii]]
-        spin2 = [spin2x[ii], spin2y[ii], spin2z[ii]]
+        m1 = numpy.float(mass1[ii])
+        m2 = numpy.float(mass2[ii])
+        spin1 = list(map(float, [spin1x[ii], spin1y[ii], spin1z[ii]]))
+        spin2 = list(map(float, [spin2x[ii], spin2y[ii], spin2z[ii]]))
         _, fm, fs = lalsim.SimIMREOBFinalMassSpin(m1, m2, spin1, spin2,
                                                   getattr(lalsim, approximant))
         final_mass[ii] = fm * (m1 + m2)