def get_sampled_measurements(self, simulation_results):
     raw_measurements = utils.get_measurement(simulation_results,
                                              self.measurement_name,
                                              self.measurement_type)
     sample_times = workalike.arange(self.start_time, self.stop_time,
                                     self.sample_period)
     if not sample_times:
         _log.error('Sample time length is 0.  ' +
                    'Measurement name: %s, stop_time: %s, period %s.',
                    self.measurement_name, self.stop_time,
                    self.sample_period)
     return [interpolation.resample_measurement(
        rm, sample_times, method=self.interpolation_method)
            for rm in raw_measurements]
    def perform(self, simulation_results, result_factory):
        fluctuations = self.get_fluctuations(simulation_results)
        taus = workalike.arange(self.tau_min,
                                self.tau_max + self.sample_period/2,
                                self.sample_period)
        variances = []
        for delta, tau in enumerate(taus):
            local_fluctuations = []
            for measurement in fluctuations:
                local_fluctuations.extend(_calculate_local_fluctuations(
                    measurement, delta, self.sample_period))
            variances.append(numpy.var(local_fluctuations))

        errors = [0 for tau in taus]
        return result_factory((taus, variances, errors), label=self.label)
 def get_sampled_measurements(self, simulation_results):
     raw_measurements = utils.get_measurement(simulation_results,
                                              self.measurement_name,
                                              self.measurement_type)
     sample_times = workalike.arange(self.start_time, self.stop_time,
                                     self.sample_period)
     if not sample_times:
         _log.error(
             'Sample time length is 0.  ' +
             'Measurement name: %s, stop_time: %s, period %s.',
             self.measurement_name, self.stop_time, self.sample_period)
     return [
         interpolation.resample_measurement(
             rm, sample_times, method=self.interpolation_method)
         for rm in raw_measurements
     ]
    def perform(self, simulation_results, result_factory):
        fluctuations = self.get_fluctuations(simulation_results)
        taus = workalike.arange(self.tau_min,
                                self.tau_max + self.sample_period / 2,
                                self.sample_period)
        variances = []
        for delta, tau in enumerate(taus):
            local_fluctuations = []
            for measurement in fluctuations:
                local_fluctuations.extend(
                    _calculate_local_fluctuations(measurement, delta,
                                                  self.sample_period))
            variances.append(numpy.var(local_fluctuations))

        errors = [0 for tau in taus]
        return result_factory((taus, variances, errors), label=self.label)
    def run(self):
        full_filename = _ospath.join(self.base_directory, self.filename)
        f = _comments.CommentFilter.from_filename(full_filename)
        reader = _csv.reader(f, dialect=_DatDialect)

        results = []
        for row in reader:
            new_row = map(float, row)
            results.append(new_row)

        raw_results = zip(*results)
        if not self.interpolate_data:
            return raw_results

        sample_times = _workalike.arange(self.xmin, self.xmax,
                                         self.sample_period)
        return _interpolation.resample_measurement(raw_results, sample_times)
    def test_interpolation_times(self):
        results = self.dr.run()

        expected_times = workalike.arange(self.xmin, self.xmax, self.sample_period)
        self.assertEqual(expected_times, results[0])
    def test_interpolation_times(self):
        results = self.dr.run()

        expected_times = workalike.arange(self.xmin, self.xmax,
                                          self.sample_period)
        self.assertEqual(expected_times, results[0])