def toframefile(filename, channel, data, start, dx, **frargs):
"""
Write numpy array data to GWF frame file using the given arguments.
Arguments:
filename : string
name of file to write
channel : string
name of channel to write
data : numpy.array
array of data to write
start : float
GPS start time (s) or minimum frequency (Hz)
dx : float
GPS time step (s) or frequency step (Hz)
Unnamed arguments are held in frargs. For usage, see documentation for
pylal.Fr.frputvect.
"""
datadict = frargs
datadict['name'] = channel
datadict['data'] = data
datadict['start'] = start
datadict['dx'] = dx
Fr.frputvect(filename, [datadict], verbose=False)
def add_noise_frames_to_signal_frames(noise_frame_files, noise_frame_channel, inj_frame_file, inj_frame_channel, ifo, outfile):
"""
Take noise frame and time-sorted injection frames, and write a single output frame containing both channels between start and stop of noise frame
"""
#Load in injection frame and create value and time arrays
inj_value_array, inj_start_time, __, inj_dt, __, __ = Fr.frgetvect1d(filename=inj_frame_file,channel='%s:%s'%(ifo,inj_frame_channel))
len_inj_array = len(inj_value_array)
inj_time_array = np.arange(inj_start_time, inj_start_time + inj_dt*len_inj_array, inj_dt)
#Initialize noise times to actually add
noise_final_array = np.zeros(len(inj_value_array))
#Load in inj frames and create value and time arrays
for i,noise_frame_file in enumerate(noise_frame_files):
#Load in noise information for this frame
noise_value_array, noise_start_time, __, noise_dt, __, __ = Fr.frgetvect1d(filename=noise_frame_file,channel='%s:%s'%(ifo,noise_frame_channel))
len_noise_array = len(noise_value_array)
noise_time_array = np.arange(noise_start_time, noise_start_time + noise_dt*len_noise_array, noise_dt)
#Keep on injection information contained within the noise frame
tmp_truth_array = (noise_time_array >= inj_time_array[0]) * (noise_time_array <= inj_time_array[-1])
tmp_value_array = noise_value_array[tmp_truth_array]
tmp_time_array = noise_time_array[tmp_truth_array]
noise_final_array[ (inj_time_array >= tmp_time_array[0]) * (inj_time_array <= tmp_time_array[-1]) ] += tmp_value_array
#Save the final noise + inj array
frames_dic = {}
frames_dic['noise'] = dict(name='%s:%s'%(ifo,noise_frame_channel), data=noise_final_array, start=inj_start_time, dx=inj_dt, type=1)
frames_dic['inj'] = dict(name='%s:%s'%(ifo,inj_frame_channel), data=inj_value_array, start=inj_start_time, dx=inj_dt, type=1)
Fr.frputvect(outfile, frames_dic.values())
def test_1d_two_channels_roundtrip(self):
""" roundtrip test call with two channels in a frame """
a = Fr.frgetvect1d("./test.dat", "Adc1")
Fr.frputvect('writetest.gwf', [{
'name': 'Adc1',
'data': a[0],
'start': a[1],
'dx': a[3],
'kind': 'ADC',
'x_unit': a[4],
'y_unit': a[5]
}, {
'name': 'reverse',
'data': a[0][::-1],
'start': a[1],
'dx': a[3],
'kind': 'ADC',
'x_unit': a[4],
'y_unit': a[5]
}])
b = Fr.frgetvect1d("writetest.gwf", "Adc1")
self.assert_(numpy.alltrue(a[0] == b[0]))
self.assert_(numpy.alltrue(a[1:] == b[1:]))
c = Fr.frgetvect1d("writetest.gwf", "reverse")
self.assert_(numpy.alltrue(a[0][::-1] == c[0]))
self.assert_(numpy.alltrue(a[1:] == c[1:]))
os.remove("writetest.gwf")
def test_1d_default_roundtrip(self):
""" roundtrip test call with default values """
a = Fr.frgetvect1d("./test.dat","Adc1")
Fr.frputvect('writetest.gwf', [{'name':'Adc1', 'data':a[0],
'start':a[1], 'dx':a[3], 'kind':'ADC', 'x_unit':a[4],
'y_unit':a[5]}])
b = Fr.frgetvect1d("writetest.gwf", "Adc1")
self.assert_(numpy.alltrue(a[0] == b[0]))
self.assert_(numpy.alltrue(a[1:] == b[1:]))
os.remove("writetest.gwf")
def test_1d_two_channels_roundtrip(self):
""" roundtrip test call with two channels in a frame """
a = Fr.frgetvect1d("./test.dat","Adc1")
Fr.frputvect('writetest.gwf', [{'name':'Adc1', 'data':a[0],
'start':a[1], 'dx':a[3], 'kind':'ADC', 'x_unit':a[4],
'y_unit':a[5]},{'name':'reverse', 'data':a[0][::-1], 'start':a[1],
'dx':a[3], 'kind':'ADC', 'x_unit':a[4], 'y_unit': a[5]}])
b = Fr.frgetvect1d("writetest.gwf", "Adc1")
self.assert_(numpy.alltrue(a[0] == b[0]))
self.assert_(numpy.alltrue(a[1:] == b[1:]))
c = Fr.frgetvect1d("writetest.gwf", "reverse")
self.assert_(numpy.alltrue(a[0][::-1] == c[0]))
self.assert_(numpy.alltrue(a[1:] == c[1:]))
os.remove("writetest.gwf")
def test_1d_keywords_roundtrip(self):
""" roundtrip test call with keyword arguments """
a = Fr.frgetvect1d("./test.dat", "Adc1", span=1)
Fr.frputvect('writetest.gwf', [{
'name': 'Adc1',
'data': a[0],
'start': a[1],
'dx': a[3],
'kind': 'ADC',
'x_unit': a[4],
'y_unit': a[5]
}])
b = Fr.frgetvect1d("writetest.gwf", "Adc1")
self.assert_(numpy.alltrue(a[0] == b[0]))
self.assert_(numpy.alltrue(a[1:] == b[1:]))
os.remove("writetest.gwf")
def write_frame(TimeSeries, ifo, usertag, outdir):
"""
Write a frame
"""
# Construct name
site=ifo.strip('1')
frame_name = '{site}-{ifo}_{usertag}-{epoch}-{datalen}.gwf'.format(
site=site, ifo=ifo, usertag=usertag,
epoch=str(int(TimeSeries.epoch)),
datalen=str(int(TimeSeries.data.length * TimeSeries.deltaT)))
channel_list = [
{'name':'%s:STRAIN'%ifo,
'data':np.array(TimeSeries.data.data),
'start':TimeSeries.epoch,
'dx':TimeSeries.deltaT,
'kind':'SIM'},
]
print 'writing frame %s...'%frame_name
frame_out_path = '%s/%s'%(os.path.abspath(outdir), frame_name)
Fr.frputvect(frame_out_path, channel_list)
#
# Generate a cache file
#
# setup url
path, filename = os.path.split(frame_out_path.strip())
url = "file://localhost%s" % os.path.abspath(os.path.join(path, filename))
# create cache entry
c=gluelal.CacheEntry.from_T050017(url)
# write to file
cache_file = frame_out_path.replace('gwf','lcf')
f=open(cache_file,'w')
f.writelines('%s\n'%str(c))
f.close()
return frame_out_path,cache_file
def test_cache(self):
# Knowing the middle of our array will be helpful, because we will put half on one frame,
# and half on hte other. We will also need this to read in a segment of hte cache that
# crosses this seam.
half = int((self.size/2)*self.delta_t)
# These need to be named so that lalapps_path2cache can turn them into a single cache file.
frmfile1 = tempfile.NamedTemporaryFile(prefix='H-frame-'+str(int(self.epoch))+'-'+str(half)+'.')
frmfile2 = tempfile.NamedTemporaryFile(prefix='H-frame-'+str(int(self.epoch+half))+'-'+str(half)+'.')
frmfile3 = tempfile.NamedTemporaryFile(prefix='H-frame-'+str(int(self.epoch+half+16))+'-'+str(half-16)+'.')
# We will need access to the actual filenames.
frmname1 = frmfile1.name
frmname2 = frmfile2.name
frmname3 = frmfile3.name
firsthalf1 = self.data1[0:(self.size/2)]
secondhalf1 = self.data1[(self.size/2):]
# This third piece will be paired up with the first one to create a cache file with a gap
# of 16 seconds after the half-way point
gaphalf1 = self.data1[(self.size/2 + 16/self.delta_t):]
# The same is done to the second dataset
firsthalf2 = self.data2[0:(self.size/2)]
secondhalf2 = self.data2[(self.size/2):]
gaphalf2 = self.data2[(self.size/2 + 16/self.delta_t):]
# Now we will create a frame file, this will hold the first half of our data
Fr.frputvect(frmname1,[{'name':'channel1', 'data':firsthalf1, 'start':int(self.epoch), 'dx':self.delta_t,'type':1},
{'name':'channel2', 'data':firsthalf2, 'start':int(self.epoch), 'dx':self.delta_t,'type':1}])
# This will hold the second half
Fr.frputvect(frmname2,[{'name':'channel1', 'data':secondhalf1, 'start':int(self.epoch+half), 'dx':self.delta_t,'type':1},
{'name':'channel2', 'data':secondhalf2, 'start':int(self.epoch+half), 'dx':self.delta_t,'type':1}])
# This third one will hold the second half, but without the first 16 seconds, so we can check importing from a cache with holes.
Fr.frputvect(frmname3,[{'name':'channel1', 'data':gaphalf1, 'start':int(self.epoch + half + 16), 'dx':self.delta_t,'type':1},
{'name':'channel2', 'data':gaphalf2, 'start':int(self.epoch + half + 16), 'dx':self.delta_t,'type':1}])
# These files are what path2cache will actually read, they will hold a list of frames
frmlist1 = tempfile.NamedTemporaryFile()
frmlist2 = tempfile.NamedTemporaryFile()
listname1 = frmlist1.name
listname2 = frmlist2.name
# The first one will contain the complete set, split over two frames
with open(listname1, 'w') as f1:
f1.write(frmname1+'\n')
f1.write(frmname2)
# This second one will use the gap frame for the second half, so there
# will be a 16 second gap in the middle of this cache
with open(listname2, 'w') as f2:
f2.write(frmname1+'\n')
f2.write(frmname3)
cache1 = tempfile.NamedTemporaryFile()
cache2 = tempfile.NamedTemporaryFile()
cachename1 = cache1.name
cachename2 = cache2.name
# Now we can actually make the caches from the list of frames
subprocess.call(['lalapps_path2cache','-i',listname1,'-o',cachename1])
subprocess.call(['lalapps_path2cache','-i',listname2,'-o',cachename2])
with self.context:
if _options['scheme'] == 'cpu':
# Reading just one channel first
ts = pycbc.frame.read_cache(cachename1,'channel1',self.epoch,self.epoch+self.size*self.delta_t)
self.checkCurrentState([ts],[self.data1],self.places)
self.assertTrue(ts.start_time == self.epoch)
self.assertTrue(ts.end_time-ts.start_time == self.size*self.delta_t)
# Now reading multiple channels
ts = pycbc.frame.read_cache(cachename1,['channel1','channel2'],self.epoch,self.epoch+self.size*self.delta_t)
self.assertTrue(type(ts) is list)
self.checkCurrentState(ts, [self.data1,self.data2], self.places)
self.assertTrue(ts[0].start_time == self.epoch)
self.assertTrue(ts[1].start_time == self.epoch)
self.assertTrue(ts[0].end_time-ts[0].start_time == self.size*self.delta_t)
self.assertTrue(ts[1].end_time-ts[1].start_time == self.size*self.delta_t)
# Now reading in a specific segment with an integer
start = self.epoch + 10
end = self.epoch + half + 50
startind = 10/self.delta_t
endind = (half + 50) / self.delta_t
ts = pycbc.frame.read_cache(cachename1, 'channel1', start=int(start), end=int(end))
# Now we'll check all the values
self.checkCurrentState((ts,), (self.data1[startind:endind],), self.places)
# The duration
self.assertTrue((40+half) - (float(ts.end_time)-float(ts.start_time)) < self.delta_t)
# And the start
self.assertTrue(ts.start_time == self.epoch+10)
# The same, but with a LIGOTimeGPS for the start and end times
ts = pycbc.frame.read_cache(cachename1, 'channel1', start=start, end=end)
# Now we'll check all the values
self.checkCurrentState((ts,), (self.data1[startind:endind],), self.places)
# The duration
self.assertTrue((40+half) - (float(ts.end_time)-float(ts.start_time)) < self.delta_t)
# And the start
self.assertTrue(ts.start_time == self.epoch+10)
# And now some cases that should raise errors
# There should be an error if there are gaps in the data requested
self.assertRaises(ValueError, pycbc.frame.read_cache,cachename2,'channel1',
self.epoch,self.epoch+self.size*self.delta_t)
# There must be a span grater than 0
self.assertRaises(ValueError, pycbc.frame.read_cache,cachename1,'channel1',
start=self.epoch,end=self.epoch)
# The start must be before the end
self.assertRaises(ValueError, pycbc.frame.read_cache,cachename1,'channel1',
start=self.epoch+1,end=self.epoch)
# Non integer times should also raise an error
badtime = lal.LIGOTimeGPS(int(self.epoch)+5,1000)
self.assertRaises(ValueError, pycbc.frame.read_cache,cachename1,'channel1',
start=self.epoch,end=badtime)
self.assertRaises(ValueError, pycbc.frame.read_cache,cachename1,'channel1',
start=float(self.epoch),end=float(badtime))
def test_frame(self):
# This is a file in the temp directory that will be deleted when it is garbage collected
frmfile = tempfile.NamedTemporaryFile()
filename = frmfile.name
# Now we will create a frame file, specifiying that it is a timeseries
Fr.frputvect(filename,[{'name':'channel1', 'data':self.data1, 'start':int(self.epoch), 'dx':self.delta_t,'type':1},
{'name':'channel2', 'data':self.data2, 'start':int(self.epoch), 'dx':self.delta_t,'type':1}])
with self.context:
if _options['scheme'] == 'cpu':
# Reading just one channel first
ts1 = pycbc.frame.read_frame(filename,'channel1')
# Chacking all values
self.checkCurrentState((ts1,),(self.data1,),self.places)
# Now checking the start time
self.assertTrue(ts1.start_time == self.epoch)
# And the duration
self.assertTrue(ts1.end_time-ts1.start_time == self.size*self.delta_t)
# Now reading multiple channels
ts2 = pycbc.frame.read_frame(filename,['channel1','channel2'])
# We should get back a list
self.assertTrue(type(ts2) is list)
self.checkCurrentState(ts2, (self.data1,self.data2), self.places)
self.assertTrue(ts2[0].start_time == self.epoch)
self.assertTrue(ts2[1].start_time == self.epoch)
self.assertTrue(ts2[0].end_time-ts2[0].start_time == self.size*self.delta_t)
self.assertTrue(ts2[1].end_time-ts2[1].start_time == self.size*self.delta_t)
# These are the times and indices for the segment we will try to read
start = self.epoch+10
end = self.epoch+50
startind = int(10/self.delta_t)
endind = int(50/self.delta_t)
# Now reading in a specific segment with an integer
ts3 = pycbc.frame.read_frame(filename, 'channel1', start=int(start), end=int(end))
# The same, but with a LIGOTimeGPS for the start and end times
ts4 = pycbc.frame.read_frame(filename, 'channel1', start=start, end=end)
# Now we will check those two TimeSeries
self.checkCurrentState((ts3,ts4), (self.data1[startind:endind],self.data1[startind:endind]), self.places)
self.assertTrue(40 - (float(ts3.end_time)-float(ts3.start_time)) < self.delta_t)
self.assertTrue(ts3.start_time == start)
self.assertTrue(40 - (float(ts4.end_time)-float(ts4.start_time)) < self.delta_t)
self.assertTrue(ts4.start_time == start)
# And now some cases that should raise errors
# There must be a span grater than 0
self.assertRaises(ValueError, pycbc.frame.read_frame,filename,'channel1',
start=self.epoch,end=self.epoch)
# The start must be before the end
self.assertRaises(ValueError, pycbc.frame.read_frame,filename,'channel1',
start=self.epoch+1,end=self.epoch)
# Non integer times should also raise an error
badtime = lal.LIGOTimeGPS(int(self.epoch)+5,1000)
self.assertRaises(ValueError, pycbc.frame.read_frame,filename,'channel1',
start=self.epoch,end=badtime)
self.assertRaises(ValueError, pycbc.frame.read_frame,filename,'channel1',
start=float(self.epoch),end=float(badtime))
def write_frame(det_data, ifo, seed, epoch, datalen, outdir):
"""
Write a frame
"""
# Construct name
site = ifo.strip('1')
frame_name = '{site}-{ifo}_{wf_name}_{seed}-{epoch}-{datalen}.gwf'.format(
site=site,
ifo=ifo,
wf_name=det_data.waveform_name,
seed=seed,
epoch=str(int(epoch)),
datalen=str(int(datalen)))
channel_list = [
{
'name': '%s:STRAIN' % ifo,
'data': np.array(det_data.td_response.data),
'start': epoch,
'dx': 1.0 / 16384,
'kind': 'SIM'
},
{
'name': '%s:SIGNAL' % ifo,
'data': np.array(det_data.td_signal.data),
'start': epoch,
'dx': 1.0 / 16384,
'kind': 'SIM'
},
{
'name': '%s:NOISE' % ifo,
'data': np.array(det_data.td_noise.data),
'start': epoch,
'dx': 1.0 / 16384,
'kind': 'SIM'
},
]
print 'writing frame %s...' % frame_name
frame_out_path = '%s/%s' % (os.path.abspath(outdir), frame_name)
Fr.frputvect(frame_out_path, channel_list)
#
# Generate a cache file
#
# setup url
path, filename = os.path.split(frame_out_path.strip())
url = "file://localhost%s" % os.path.abspath(os.path.join(path, filename))
# create cache entry
c = gluelal.CacheEntry.from_T050017(url)
# write to file
cache_file = frame_out_path.replace('gwf', 'lcf')
f = open(cache_file, 'w')
f.writelines('%s\n' % str(c))
f.close()
return frame_out_path, cache_file
def generate_gwf(self, mdc, directory, channel="SCIENCE", force=False):
"""
Produce the gwf file which corresponds to the MDC set over the period of this frame.
Parameters
----------
mdc : MDCSet object
The MDC set which should be used to produce this frame.
directory : str
The root directory where all of the frames are to be stored, for example
"/home/albert.einstein/data/mdc/frames/"
would cause the SineGaussian injections to be made in the directories under
"/home/albert.einstein/data/mdc/frames/sg"
channel : str
The name of the channel which the injections should be made into. This is prepended by the initials
for each interferometer, so there will be a channel for each interferometer in the gwf.
force : bool
If true this forces the recreation of a GWF file even if it already exists.
Outputs
-------
gwf
The GWF file for this frame.
"""
ifosstr = "".join(set(ifo[0] for ifo in self.ifos))
family = mdc.waveforms[0].waveform
filename = "{}-{}-{}-{}.gwf".format(ifosstr, family, self.start, self.duration)
head_date = str(self.start)[:5]
frameloc = directory+"/"+mdc.directory_path()+"/"+head_date+"/"
#print frameloc, filename
if not os.path.isfile(frameloc + filename) or force:
data = []
# Define the start point of the time series top be generated for the injection
epoch = lal.LIGOTimeGPS(self.start)
# Loop through each interferometer
for ifo in self.ifos:
# Calculate the number of samples in the timeseries
nsamp = (self.end-self.start)*16384
# Make the timeseries
h_resp = lal.CreateREAL8TimeSeries("inj time series", epoch, 0, 1.0/16384, lal.StrainUnit, nsamp)
# Loop over all of the injections corresponding to this frame
rowlist = self.get_rowlist(mdc)
if len(rowlist)==0: return
for row in rowlist:
sim_burst = mdc.waveforms[row]
# Produce the time domain waveform for this injection
hp, hx = lalburst.GenerateSimBurst(sim_burst, 1.0/16384);
# Apply detector response
det = lalsimulation.DetectorPrefixToLALDetector(ifo)
# Produce the total strains
h_tot = lalsimulation.SimDetectorStrainREAL8TimeSeries(hp, hx,
sim_burst.ra, sim_burst.dec, sim_burst.psi, det)
# Inject the waveform into the overall timeseries
lalsimulation.SimAddInjectionREAL8TimeSeries(h_resp, h_tot, None)
# Write out the data to the list which will eventually become our frame
data.append({"name": "%s:%s" % (ifo, channel),
"data": h_resp.data.data,
"start": float(epoch),
"dx": h_resp.deltaT,
"kind": "SIM"})
# Make the directory in which to store the files
# if it doesn't exist already
mkdir(frameloc)
# Write out the frame file
Fr.frputvect(frameloc+filename, data)
