def lal(self): """Produces a LAL time series object equivalent to self. Returns ------- lal_data : {lal.*TimeSeries} LAL time series object containing the same data as self. The actual type depends on the sample's dtype. If the epoch of self is 'None', the epoch of the returned LAL object will be LIGOTimeGPS(0,0); otherwise, the same as that of self. Raises ------ TypeError If time series is stored in GPU memory. """ lal_data = None ep = self._epoch if self._data.dtype == _numpy.float32: lal_data = _lal.CreateREAL4TimeSeries("",ep,0,self.delta_t,_lal.SecondUnit,len(self)) elif self._data.dtype == _numpy.float64: lal_data = _lal.CreateREAL8TimeSeries("",ep,0,self.delta_t,_lal.SecondUnit,len(self)) elif self._data.dtype == _numpy.complex64: lal_data = _lal.CreateCOMPLEX8TimeSeries("",ep,0,self.delta_t,_lal.SecondUnit,len(self)) elif self._data.dtype == _numpy.complex128: lal_data = _lal.CreateCOMPLEX16TimeSeries("",ep,0,self.delta_t,_lal.SecondUnit,len(self)) lal_data.data.data[:] = self.numpy() return lal_data
def lal(self): """ Returns a LAL Object that contains this data """ lal_data = None if type(self._data) is not _numpy.ndarray: raise TypeError("Cannot return lal type from the GPU") elif self._data.dtype == _numpy.float32: lal_data = _lal.CreateREAL4TimeSeries("", self._epoch, 0, self.delta_t, _lal.lalSecondUnit, len(self)) elif self._data.dtype == _numpy.float64: lal_data = _lal.CreateREAL8TimeSeries("", self._epoch, 0, self.delta_t, _lal.lalSecondUnit, len(self)) elif self._data.dtype == _numpy.complex64: lal_data = _lal.CreateCOMPLEX8TimeSeries("", self._epoch, 0, self.delta_t, _lal.lalSecondUnit, len(self)) elif self._data.dtype == _numpy.complex128: lal_data = _lal.CreateCOMPLEX16TimeSeries("", self._epoch, 0, self.delta_t, _lal.lalSecondUnit, len(self)) lal_data.data.data[:] = self._data return lal_data
def get_strain(self, fs, tmin=0, tmax=None, noise_sqrt_Sh=0, noise_seed=0): """ Generate strain time series of a continuous-wave signal in the detector frame. @param fs: sampling frequency of strain time series, in Hz @param tmin: start time for strain time series, as offsets from self.__tstart @param tmax: start time for strain time series, as offsets from self.__tstart @param noise_sqrt_Sh: if >0, add Gaussian noise with square-root single-sided power spectral density given by this value, in Hz^(-1/2) @param noise_seed: use this need for the random number generator used to create noise @return (@b t, @b h), where: @b t = start of time strain time series, in GPS seconds; @b h = strain time series """ # process tmin/tmax range (interpreted relative to self.__tstart) if (tmin < 0) or (tmin>=self.__Tdata): raise ValueError('tmin must be within [0,{}).'.format(self.__Tdata)) if tmax is None: tmax = self.__Tdata elif (tmax <= 0) or (tmax>self.__Tdata): raise ValueError('tmax must be within (0,{}].'.format(self.__Tdata)) tspan = tmax-tmin # create REAL4TimeSeries to store output time series Nh = int(fs*tspan) h = lal.CreateREAL4TimeSeries("h", self.__tstart+tmin, 0, 1.0 / fs, lal.DimensionlessUnit, Nh) # generate strain time series self._simulate_coherent_gw(h, noise_sqrt_Sh, noise_seed) return (h.epoch, h.data.data)
def get_strain(self, fs, noise_sqrt_Sh=0): """ Generate strain time series of a continuous-wave signal in the detector frame. @param fs: sampling frequency of strain time series, in Hz @param noise_sqrt_Sh: if >0, add Gaussian noise with square-root single-sided power spectral density given by this value, in Hz^(-1/2) @return (@b t, @b h), where: @b t = start of time strain time series, in GPS seconds; @b h = strain time series """ # create REAL4TimeSeries to store output time series N_h = int(fs * self.__T) h = lal.CreateREAL4TimeSeries("h", self.__gps_t0, 0, 1.0 / fs, lal.DimensionlessUnit, N_h) # generate strain time series self._simulate_coherent_gw(h, noise_sqrt_Sh) return (h.epoch, h.data.data)
def get_strain_blocks(self, fs, T_block, noise_sqrt_Sh=0): """ Generate strain time series of a continuous-wave signal in the detector frame, in contiguous blocks. @param fs: sampling frequency of strain time series, in Hz @param T_block: length of each block, in seconds; should divide evenly into @b T @param noise_sqrt_Sh: if >0, add Gaussian noise with square-root single-sided power spectral density given by this value, in Hz^(-1/2) @return (@b t, @b h, @b i, @b N), where: @b t = start of time strain time series, in GPS seconds; @b h = strain time series; @b i = block index, starting from zero; @b N = number of blocks This is a Python generator function and so should be called as follows: ~~~ S = CWSimulator(...) for t, h, i, N in S.get_strain_blocks(...): ... ~~~ """ # work out number of blocks N_block = int(round(self.__T / T_block)) if T_block * N_block > self.__T: raise ValueError( "Length of block T_block=%g does not divide evenly into T=%g" % (T_block, self.__T)) # create REAL4TimeSeries to store output time series N_h = int(fs * T_block) h = lal.CreateREAL4TimeSeries("h", self.__gps_t0, 0, 1.0 / fs, lal.DimensionlessUnit, N_h) # generate strain time series in blocks of length 'T_block' for i_block in xrange(0, N_block): self._simulate_coherent_gw(h, noise_sqrt_Sh) yield h.epoch, h.data.data, i_block, N_block h.epoch += T_block
def _make_series(self, array, epoch, row_number): """For internal use only.""" para = { "name": "%s_%d_%d" % (self.instrument, self.bank_number, row_number), "epoch": epoch, "deltaT": self.deltaT, "f0": 0, "sampleUnits": lal.DimensionlessUnit, "length": len(array) } if array.dtype == numpy.float32: tseries = lal.CreateREAL4TimeSeries(**para) elif array.dtype == numpy.float64: tseries = lal.CreateREAL8TimeSeries(**para) elif array.dtype == numpy.complex64: tseries = lal.CreateCOMPLEX8TimeSeries(**para) elif array.dtype == numpy.complex128: tseries = lal.CreateCOMPLEX16TimeSeries(**para) else: raise ValueError("unsupported type : %s " % array.dtype) tseries.data.data = array return tseries
# check module load print("checking module load ...") import lal from lal import globalvar as lalglobalvar lal_c_si = lal.C_SI lal_180_pi = lal.LAL_180_PI print("PASSED module load") # check memory allocation print("checking memory allocation ...") if not lal.NoDebug: lal.CheckMemoryLeaks() mem1 = lal.Detector() mem2 = lal.CreateCOMPLEX8Vector(5) mem3 = lal.CreateREAL8Vector(3) mem4 = lal.CreateREAL4TimeSeries("test", lal.LIGOTimeGPS(0), 100, 0.1, lal.DimensionlessUnit, 10) print("*** below should be an error message from CheckMemoryLeaks() ***") try: lal.CheckMemoryLeaks() expected_exception = True except: pass assert (not expected_exception) print("*** above should be an error message from CheckMemoryLeaks() ***") del mem1 del mem2 del mem3 del mem4 lal.CheckMemoryLeaks() print("PASSED memory allocation") else: