Exemple #1
0
    def __init__(self, **kwargs):

        self._run_parameters = kwargs

        filename = kwargs['filename']
        self._filename = filename
        scrunch = kwargs.get('scrunch', 1)
        self._scrunch = scrunch  # For identifying process.
        self._data_ring = MockRing(filename, scrunch)
        #self._data_ring = power_data_io.MockRing(filename, scrunch)

        #parameters = get_parameters(filename)
        #print parameters
        parameters = self._data_ring.get_parameters()
        self._parameters = parameters
        ####

        if kwargs.get('to_2_DM_diag', False):
            freq0 = parameters['freq0']
            delta_f = parameters['delta_f']
            nfreq = parameters['nfreq']
            freq_max = max(freq0, freq0 + delta_f * (nfreq - 1))
            freq_min = min(freq0, freq0 + delta_f * (nfreq - 1))
            dm_diag = misc.diag_dm(parameters['delta_t'], delta_f, freq_max)
            self._max_dm = 0.9 * 2 * dm_diag
            self._overlap = 1.5 * (misc.disp_delay(2 * dm_diag, freq_min) -
                                   misc.disp_delay(2 * dm_diag, freq_max))
            self._time_block = 3.0 * self._overlap
        else:
            self._time_block = kwargs.get('time_block', TIME_BLOCK)
            self._overlap = kwargs.get('overlap', OVERLAP)
            self._max_dm = kwargs.get('max_dm', MAX_DM)

        #print self._overlap, self._time_block, dm_diag

        self._min_search_dm = kwargs.get('min_search_dm', MIN_SEARCH_DM)

        self._Transformer = dedisperse.DMTransform(
            parameters['delta_t'],
            parameters['nfreq'],
            parameters['freq0'],
            parameters['delta_f'],
            self._max_dm,
            jon=USE_JON_DD,
        )

        print(
            "Filename: %s, delta_t: %f, min_dm: %f, max_dm: %f, ndm: %d,"
            " time_block: %f" %
            (filename, parameters['delta_t'], self._min_search_dm,
             self._max_dm, self._Transformer.ndm, self._time_block))

        #self._df = parameters['delta_f']
        #self._nfreq = parameters['nfreq']
        #self._f0 = parameters['freq0']

        nrecords_block = int(
            math.ceil(self._time_block /
                      (parameters['ntime_record'] * parameters['delta_t'])))

        #initialize sim object, if there are to be simulated events
        if SIMULATE:
            self._sim_source = simulate.RandSource(
                alpha=alpha,
                f_m=f_m,
                f_sd=f_sd,
                bw_m=bw_m,
                bw_sd=bw_sd,
                t_m=t_m,
                t_sd=t_sd,
                s_m=s_m,
                s_sd=s_sd,
                dm_m=dm_m,
                dm_sd=dm_sd,
                event_rate=sim_rate,
                file_params=self._parameters,
                t_overlap=self._overlap,
                nrecords_block=nrecords_block)

        self._cal_spec = 1.
        self._dedispersed_out_group = None

        self.set_search_method()
        self.set_trigger_action()