Exemple #1
0
    savename = 'tm1_rec_example_onepc.eps'
else:
    npcs = waveform_data.nwaves
    savename = 'tm1_rec_example_allpcs.eps'

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Test Waveform
#

print "Building test waveform"

#
# Create test waveform
#
waveform = pwave.Waveform(eos=eos_example,
                          mass=mass_example,
                          viscosity=viscosity,
                          distance=50)
waveform.reproject_waveform()
waveform.compute_characteristics()

# Get this waveform's amplitude and SNR
targetAmp = waveform.hplus.max()
targetH = waveform.hplus.to_frequencyseries()

# Standardise
waveform_FD, target_fpeak, _ = \
        ppca.condition_spectrum(waveform.hplus.data,
                nsamples=nTsamples)

# Take FFT:
waveform_FD = ppca.unit_hrss(waveform_FD.data,
Exemple #2
0
f.writelines("# rho_full rho_post Dhor Dsens Rate\n")

rho_min = 100
rho_max = 0

for w, wave in enumerate(waveform_data.waves):

    print "SNR for %s, %s ,%s (%d of %d)" % (wave['eos'], wave['mass'],
                                             wave['viscosity'], w + 1,
                                             waveform_data.nwaves)

    #
    # Create test waveform
    #
    waveform = pwave.Waveform(eos=wave['eos'],
                              mass=wave['mass'],
                              viscosity=wave['viscosity'],
                              distance=reference_distance)
    waveform.reproject_waveform()

    hplus_padded = pycbc.types.TimeSeries(np.zeros(16384),
                                          delta_t=waveform.hplus.delta_t)
    hplus_padded.data[:len(waveform.hplus)] = np.copy(waveform.hplus.data)
    Hplus = hplus_padded.to_frequencyseries()

    #
    # Construct PSD
    #
    psd = pwave.make_noise_curve(fmax=Hplus.sample_frequencies.max(),
                                 delta_f=Hplus.delta_f,
                                 noise_curve=noise_curve)
Exemple #3
0
#           2*frequencies[abs(scales-0.5*max(scales)).argmin()])
#

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Waveform Generation
#

eos = "tm1"
mass = "135135"

#
# Create the list of dictionaries which comprises our catalogue
#
#waveform_data = pdata.WaveData(eos=eos, mass=mass, viscosity='lessvisc')

waveform = pwave.Waveform(eos=eos, mass=mass, viscosity="lessvisc")

waveform.reproject_waveform()

Hplus = waveform.hplus.to_frequencyseries()

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Wavelet analysis
#
cwt_result = ppca.build_cwt(waveform.hplus, mother_freq=3, fmin=500)

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Plotting
#

fig, ax_cont, ax_ts, ax_fs = tripleplot(cwt_result)
Exemple #4
0
def build_catalogues(waveform_data,
                     fshift_center,
                     nTsamples=16384,
                     delta_t=1. / 16384):
    """
    Build the data matrix.  waveform_data is the pmns_waveform_data.WaveData()
    class which contains the list of dictionaries of waveform data
    """

    nFsamples = nTsamples / 2 + 1
    sample_times = np.arange(0, delta_t * nTsamples, delta_t)

    # Preallocation
    timedomain_cat = np.zeros(shape=(waveform_data.nwaves, len(sample_times)))
    original_cat = np.zeros(shape=(waveform_data.nwaves, nFsamples),
                            dtype=complex)
    fpeaks = np.zeros(waveform_data.nwaves)

    # Preallocate for the TF maps
    example_waveform = pmns_waveform.Waveform(
        eos=waveform_data.waves[0]['eos'],
        mass=waveform_data.waves[0]['mass'],
        viscosity=waveform_data.waves[0]['viscosity'])
    example_waveform.reproject_waveform()
    example_map = example_tfmap(waveform=example_waveform, delta_t=delta_t)

    mapdims = np.shape(example_map['map'])
    times = example_map['times']
    frequencies = example_map['frequencies']
    scales = example_map['scales']

    original_image_cat = np.zeros(shape=(waveform_data.nwaves, mapdims[0],
                                         mapdims[1]))
    align_image_cat = np.zeros(shape=(waveform_data.nwaves, mapdims[0],
                                      mapdims[1]))

    for w, wave in enumerate(waveform_data.waves):

        print "Building waveform for %s, %s, %s (%d of %d)" % (
            wave['eos'], wave['mass'], wave['viscosity'], w + 1,
            waveform_data.nwaves)

        #
        # Create waveform instance: pmns_utils
        #
        waveform = pmns_waveform.Waveform(eos=wave['eos'],
                                          mass=wave['mass'],
                                          viscosity=wave['viscosity'])
        waveform.reproject_waveform()

        # Waveform conditioning
        original_spectrum, fpeaks[w], timeseries = \
                condition_spectrum(waveform.hplus.data, nsamples=nTsamples)

        # Populate time series catalogue
        timedomain_cat[w, :] = np.copy(timeseries.data)

        # Time-frequency maps
        tfmap = build_cwt(
            pycbc.types.TimeSeries(waveform.hplus.data, delta_t=delta_t))
        original_image_cat[w, :, :] = tfmap['map']

        aligned_tfmap = align_cwt(tfmap, fpeaks[w])
        align_image_cat[w, :, :] = aligned_tfmap

        del waveform

        # Normalise to unit hrss
        original_spectrum = unit_hrss(original_spectrum,
                                      delta=original_spectrum.delta_f,
                                      domain='frequency')

        # Add to catalogue
        original_frequencies = np.copy(original_spectrum.sample_frequencies)
        original_cat[w, :] = np.copy(original_spectrum.data)

    return (sample_times, original_frequencies, timedomain_cat, original_cat,
            fpeaks, original_image_cat, align_image_cat, times, scales,
            frequencies)
Exemple #5
0
hp.data *= 1.4
Hp = hp.to_frequencyseries()

print max(hp)

#
# Generate own waveform
#
from pmns_utils import pmns_waveform as pwave
eos = "tm1"
mass = "135135"
total_mass = 2 * 1.35
mass1 = 1.35
mass2 = 1.35
waveform = pwave.Waveform(eos=eos,
                          mass=mass,
                          viscosity="lessvisc",
                          distance=100)
waveform.reproject_waveform()
waveform_tilde = waveform.hplus.to_frequencyseries()

from matplotlib import pyplot as pl
f, ax = pl.subplots(nrows=2, ncols=2)
ax[0][0].plot(hp.sample_times, hp)
ax[0][1].plot(waveform.hplus.sample_times, waveform.hplus)
ax[0][0].set_ylim(-1.5e-22, 1.5e-22)
ax[0][1].set_ylim(-1.5e-22, 1.5e-22)
ax[1][0].loglog(Hp.sample_frequencies, abs(Hp))
ax[1][1].loglog(waveform_tilde.sample_frequencies, abs(waveform_tilde))
pl.show()
Exemple #6
0

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Set noise curves and example waveform

instruments = ['aLIGO', 'A+', 'Voyager', 'CE1', 'ET-D']
fmax = 4096
fmin = 10
delta_f = 0.5

# --- Example signal
eos = "tm1"
mass = "135135"
viscosity = "lessvisc"

waveform = pwave.Waveform(eos=eos, mass=mass, viscosity=viscosity, distance=50)
waveform.reproject_waveform()
waveform.compute_characteristics()
Hplus = waveform.hplus.to_frequencyseries()

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Build curves and plot on the fly

f, ax = pl.subplots()

ax.semilogy(Hplus.sample_frequencies,
            2 * np.sqrt(Hplus.sample_frequencies) * abs(Hplus.data),
            label='BNS @ 50 Mpc',
            color='k')

lines = ["-", "--", "-.", ":"]
# Dump time-domain waveforms
#
#injections = {}
injections = []
names = []

for w, wave in enumerate(waveform_data.waves):

    print "Projecting %s, %s ,%s (%d of %d)" % (wave['eos'], wave['mass'],
                                                wave['viscosity'], w + 1,
                                                waveform_data.nwaves)

    # --- Fourier Domain Analysis --- #
    # Get complex spectrum of this waveform
    waveform = pwave.Waveform(eos=wave['eos'],
                              mass=wave['mass'],
                              viscosity=wave['viscosity'])
    waveform.reproject_waveform()

    name = wave['eos'] + '_' + wave['mass']
    names.append(name)

    #injections[name] = (pwave.taper_start(waveform.hplus),
    #                    pwave.taper_start(waveform.hcross))
    injections.append((pwave.taper_start(waveform.hplus),
                       pwave.taper_start(waveform.hcross)))

    # Standardise
    waveform_FD, target_fpeak, _ = ppca.condition_spectrum(waveform.hplus.data,
                                                           nsamples=nTsamples)
Exemple #8
0
SNR = pycbc.filter.sigma(Hp, psd=psd, low_frequency_cutoff=1000)
print 'pycbc snr=', SNR

amp = wfutils.amplitude_from_polarizations(hp, hc)

#
# Generate own waveform
#
from pmns_utils import pmns_waveform as pwave
eos = "shen"
mass = "135135"
total_mass = 2 * 1.35
mass1 = 1.35
mass2 = 1.35
waveform = pwave.Waveform(eos=eos,
                          mass=mass,
                          viscosity="oldvisc",
                          distance=params['distance'])
waveform.reproject_waveform(theta=params['inclination'])
waveform_tilde = waveform.hplus.to_frequencyseries()

waveform.amp = wfutils.amplitude_from_polarizations(waveform.hplus,
                                                    waveform.hcross)

psd = pwave.make_noise_curve(fmax=waveform_tilde.sample_frequencies.max(),
                             delta_f=waveform_tilde.delta_f,
                             noise_curve='aLIGO')

SNR = pycbc.filter.sigma(waveform_tilde, psd=psd, low_frequency_cutoff=1000)
print 'my snr=', SNR

#