Fake Data

lsl.sim - Simulate various types of LWA data. The following follow DP format writers are avaliable:

  • tbw
  • tbn
  • drx
In addition, there are two simulation modules to generate fake data sets::
  • dp - generate DP-level data sets for basic signals and point source
  • vis - generate visibility data sets for use with the aipy module

Writers

New in version 0.3.

TBW

Python module for creating creating, validating, and writing simulated TBW frames to a file.

class lsl.sim.tbw.SimFrame(stand=None, frameCount=None, dataBits=12, obsTime=None, xy=None)

Bases: lsl.reader.tbw.Frame

tbw.SimFrame extends the lsl.reader.tbw.Frame object to yield a method for easily creating DP ICD-compliant raw TBW frames. Frames created with this method can be written to a file via the methods writeRawFrame() function.

createRawFrame()
Re-express a simulated TBW frame as a numpy array of unsigned 8-bit integers. Returns a numpy array if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
isValid(raiseErrors=False)
Check if simulated TBW frame is valid or not. Valid frames return True and invalid frames False. If the ‘raiseErrors’ keyword is set, isValid() raises an error when a problem with the frame structure is encountered.
loadFrame(tbwFrame)
Populate the a tbw.SimFrame object with a pre-made frame.
writeRawFrame(fh)
Write a simulated TBW frame to a filehandle if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
lsl.sim.tbw.frame2frame(tbwFrame)
Convert a tbw.Frame/tbw.SimFrame object to a raw DP TBW frame.

TBN

Python module for creating creating, validating, and writing simulated TBN frames to a file.

class lsl.sim.tbn.SimFrame(stand=None, pol=None, frameCount=None, obsTime=None, iq=None)

Bases: lsl.reader.tbn.Frame

tbn.SimFrame extends the lsl.reader.tbn.Frame object to yield a method for easily creating DP ICD-compliant raw TBN frames. Frames created with this method can be written to a file via the methods writeRawFrame() function.

createRawFrame()
Re-express a simulated TBN frame as a numpy array of unsigned 8-bit integers. Returns a numpy array if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
isValid(raiseErrors=False)
Check if simulated TBN frame is valid or not. Valid frames return True and invalid frames False. If the ‘raiseErrors’ keyword is set, isValid raises an error when a problem is encountered.
loadFrame(tbnFrame)
Populate the a tbn.SimFrame object with a pre-made frame.
writeRawFrame(fh)
Write a simulated TBN frame to a filehandle if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
lsl.sim.tbn.frame2frame(tbnFrame)
Convert a tbn.Frame object to a raw DP TBN frame.

DRX

Python module for creating creating, validating, and writing simulated DRX frames to a file.

class lsl.sim.drx.SimFrame(beam=None, tune=None, pol=None, filterCode=None, timeOffset=None, frameCount=None, obsTime=None, flags=None, iq=None)

Bases: lsl.reader.drx.Frame

drx.SimFrame extends the lsl.reader.tbn.Frame object to yield a method for easily creating DP ICD-compliant raw DRX frames. Frames created with this method can be written to a file via the methods writeRawFrame() function.

createRawFrame()
Re-express a simulated DRX frame as a numpy array of unsigned 8-bit integers. Returns a numpy array if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
isValid(raiseErrors=False)
Check if simulated DRX frame is valid or not. Valid frames return True and invalid frames False. If the ‘raiseErrors’ keyword is set, isValid raises an error when a problem is encountered.
loadFrame(drxFrame)
Populate the a drx.SimFrame object with a pre-made frame.
writeRawFrame(fh)
Write a simulated DRX frame to a filehandle if the frame is valid. If the frame is not ICD-compliant, a errors.baseSimError-type error is raised.
lsl.sim.drx.frame2frame(drxFrame)
Convert a drx.Frame object to a raw DP DRX frame.

Simulators

Digitial Processor Data

New in version 0.3.

Module to simulate observations made with the DP system.

lsl.sim.dp.basicSignal(fh, stands, nFrames, mode='DRX', filter=6, bits=12, tStart=0)

Generate a collection of frames with a basic test signal for TBW, TBN, and DRX. The signals for the three modes are:

TBW
  • noise + 40 MHz signal for x-pol.
  • noise + 60 MHz signal for y-pol. -> odd stands
  • noise + 30 MHz signal for x-pol.
  • noise + 50 MHz signal for ypol. -> even stands
TBN
  • noise + (sampleRate/4) kHz signal for x-pol. and noise + (-sampleRate/4) for y-pol.
DRX
  • noise + (sampleRate/4) kHz signal for x-pol. and noise +
(-sampleRate/4) for y-pol. -> tuning 1
  • noise + (-sampleRate/3) kHz signal for x-pol. and noise +
(sampleRate/3) for y-pol. -> tuning 2

All modes need to have stands (beams in the case of DRX) and number of frames to generate. TBW also needs to ‘bits’ keyword set to generate either 12-bit or 4-bit data. The TBN and DRX frames need the ‘filter’ keyword set to specify the filter width. In addition, the ‘stands’ argument is interpreted as beam numbers for DRX.

Visibility Data

Module for generating simulated arrays and visilibity data. The chief functions of this module are:

buildSimArray
given a station object, a list of stands, and a list of frequencies, build a AIPY AntennaArray-like object. This module can also generate AntennaArray objects with positional errors by setting the ‘PosError’ keyword to a positive value.
buildSimData
given a SimArray and a list of aipy.src sources, build up a collection of visibilities for a given set of Julian dates
scaleData
given a dictionary of simulated visibilities from buildSimData, apply antenna-based gains and delays to the visibilities
shiftData

given a dictionary of simulated visibilities from buildSimData, shift the uvw coordinates of the visibilities. .. note:

This only changes the uvw values and does not phase-shift the data.

The format of the data dictionaries mentioned above is:

primary keys

The primary keys store the major aspects of the visiblity data, e.g., frequency coverage, baseline pairs, uvw coordinates, etc. Valid keys are:

  • freq - list of frequencies used in Hz
  • isMasked - whether or not the visibility data have been masked (numpy.compress’d)
  • bls - list of baselines in (stand 1, stand2) format
  • uvw - list of uvw coordinates as 3-element numpy arrays
  • vis - list of visibility numpy arrays
  • wgt - list of weight arrays with the same length as the visilitity arrays
  • msk - list of mask arrays used for the data. 1 = masked, 0 = valid
  • jd - list of Julian dates associated with each list element
secondary keys

The bls, uvw, vis, wgt, msk, and jd primary keys also have secondary keys that indicate which polarizations are being stored. Valid keys are:

  • xx
  • yy
  • xy
  • yx

In addition to simulation functions, this module includes buildGriddedImage which takes a dictionary of visibilities and returns and aipy.im.ImgW object.

Changed in version 0.3: This module was formerly called lsl.sim.sim

class lsl.sim.vis.Antenna(x, y, z, beam, phsoff=[, 0.0, 0.0], bp_r=array([, 1], ), bp_i=array([, 0], ), amp=1, pointing=(0.0, 1.5707963267948966, 0), stand=0, **kwargs)

Modification to the aipy.amp.Antenna class to also store the stand ID number in the Antenna.stand attribute. This also add a getBeamShape attribute that pulls in the old vis.getBeamShape function.

get_beam_shape(pol='x')
Return a 360 by 90 by nFreqs numpy array showning the beam pattern of a particular antenna in the array. The first two dimensions of the output array contain the azimuth (from 0 to 359 degrees in 1 degree steps) and altitlude (from 0 to 89 degrees in 1 degree steps).
class lsl.sim.vis.AntennaArray(location, ants, **kwargs)

Modification to the aipy.ant.AntennaArray class to add a fuction to retrieve the stands stored in the AntennaArray.ants attribute. Also add a function to set the array time from a UNIX timestamp.

get_stands()
Return a numpy array listing the stands found in the AntennaArray object.
set_unixtime(timestamp)
Set the array time using a UNIX timestamp (epoch 1970).
lsl.sim.vis.buildSimArray(station, stands, freq, jd=None, PosError=0.0, ForceFlat=False, verbose=False)

Build a AIPY AntennaArray for simulation purposes. Inputs are a station object defined from the lwa_common module, a numpy array of stand numbers, and a numpy array of frequencies in either Hz of GHz. Optional inputs are a Julian Date to set the array to and a positional error terms that perturbs each of the stands in x, y, and z. The output of this module is an AIPY AntennaArray object.

The shape of the antenna response is either flat (gain of 1 in all directions) or modeled by a collection of spherical harmonics that are poly- nomials in frequency. The spherical harmonics are used if the file ‘beam_shape.npz’ is found in the current directory.

lsl.sim.vis.buildSimData(aa, srcs, jd=None, phaseCenter='z', baselines=None, mask=None, verbose=False)
Given an AIPY AntennaArray object and a dictionary of sources from aipy.src.get_catalog, returned a data dictionary of simulated data taken at zenith. Optinally, the data can be masked using some referenced (observed) data set or only a specific sub-set of baselines.
lsl.sim.vis.scaleData(dataDict, amps, delays)
Apply a set of antenna-based gains and phase delays to a data dictionary. Returned the new scaled and delayed dictionary.
lsl.sim.vis.shiftData(dataDict, aa)
Shift the uvw coordinates in one data dictionary to a new set of uvw coordinates that correspond to a new AntennaArray object. This is useful for looking at how positional errors in the array affect the data.
lsl.sim.vis.buildGriddedImage(dataDict, MapSize=30, MapRes=0.5, MapWRes=0.10000000000000001, pol='xx', chan=None)
Given a data dictionary, build an aipy.img.ImgW object of gridded uv data which can be used for imaging. The ImgW object itself is returned by this function to make it more versatile.

Table Of Contents

Previous topic

Post-Acquisition Beam Forming

Next topic

Simulated Stand Response

This Page