time_series.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
#ifndef CORE_ANALYSIS_TIME_SERIES_H_
#define CORE_ANALYSIS_TIME_SERIES_H_
 
#include <functional>
#include <unordered_map>
#include <vector>
#include "core/analysis/reduce.h"
#include "core/real_t.h"
#include "core/util/root.h"
 
namespace bdm {
 
class Simulation;
 
namespace experimental {
 
class DataTransformer {
 public:
  virtual ~DataTransformer() = default;
 
  virtual void TransformXValues(const std::vector<real_t>& old_x_values,
                                std::vector<real_t>& new_x_values) const = 0;
  virtual void TransformYValues(const std::vector<real_t>& old_y_values,
                                std::vector<real_t>& new_y_values) const = 0;
  virtual void TransformYErrorLow(
      const std::vector<real_t>& old_y_error_low,
      std::vector<real_t>& new_y_error_low) const = 0;
  virtual void TransformYErrorHigh(
      const std::vector<real_t>& old_y_error_high,
      std::vector<real_t>& new_y_error_high) const = 0;
 
  BDM_CLASS_DEF(DataTransformer, 1);
};
 
class LinearTransformer : public DataTransformer {
 public:
  void TransformXValues(const std::vector<real_t>& old_x_values,
                        std::vector<real_t>& new_x_values) const final;
 
  void TransformYValues(const std::vector<real_t>& old_y_values,
                        std::vector<real_t>& new_y_values) const final;
 
  void TransformYErrorLow(const std::vector<real_t>& old_y_error_low,
                          std::vector<real_t>& new_y_error_low) const final;
 
  void TransformYErrorHigh(const std::vector<real_t>& old_y_error_high,
                           std::vector<real_t>& new_y_error_high) const final;
 
  void SetXSlope(real_t slope);
  void SetXIntercept(real_t intercept);
  void SetYSlope(real_t slope);
  void SetYIntercept(real_t intercept);
  void SetYErrorLowSlope(real_t slope);
  void SetYErrorLowIntercept(real_t intercept);
  void SetYErrorHighSlope(real_t slope);
  void SetYErrorHighIntercept(real_t intercept);
 
 private:
  real_t x_slope_ = 1.0;
  real_t x_intercept_ = 0.0;
  real_t y_slope_ = 1.0;
  real_t y_intercept_ = 0.0;
  real_t y_error_low_slope_ = 1.0;
  real_t y_error_low_intercept_ = 0.0;
  real_t y_error_high_slope_ = 1.0;
  real_t y_error_high_intercept_ = 0.0;
 
  BDM_CLASS_DEF_OVERRIDE(LinearTransformer, 1);
};
 
class TimeSeries {
 public:
  struct Data {
    Data();
    Data(real_t (*ycollector)(Simulation*), real_t (*xcollector)(Simulation*));
    Data(Reducer<real_t>* y_reducer_collector,
         real_t (*xcollector)(Simulation*));
    Data(const Data&);
    ~Data();
 
    Data& operator=(const Data& other);
 
    Reducer<real_t>* y_reducer_collector = nullptr;
    real_t (*ycollector)(Simulation*) = nullptr;  
    real_t (*xcollector)(Simulation*) = nullptr;  
    std::vector<real_t> x_values;
    std::vector<real_t> y_values;
    std::vector<real_t> y_error_low;
    std::vector<real_t> y_error_high;
    BDM_CLASS_DEF_NV(Data, 1);
  };
 
  static void Load(const std::string& full_filepath, TimeSeries** restored);
 
  static void Merge(
      TimeSeries* merged, const std::vector<TimeSeries>& time_series,
      const std::function<void(const std::vector<real_t>&, real_t*, real_t*,
                               real_t*)>& merger);
 
  static real_t ComputeError(const TimeSeries& ts1, const TimeSeries& ts2);
 
  TimeSeries();
  TimeSeries(const TimeSeries& other);
  TimeSeries(TimeSeries&& other) noexcept;
 
  TimeSeries& operator=(TimeSeries&& other) noexcept;
  TimeSeries& operator=(const TimeSeries& other);
 
  void AddCollector(const std::string& id, real_t (*ycollector)(Simulation*),
                    real_t (*xcollector)(Simulation*) = nullptr);
 
  void AddCollector(const std::string& id, Reducer<real_t>* y_reducer_collector,
                    real_t (*xcollector)(Simulation*) = nullptr);
 
  void Add(const std::string& id, const std::vector<real_t>& x_values,
           const std::vector<real_t>& y_values);
 
  void Add(const std::string& id, const std::vector<real_t>& x_values,
           const std::vector<real_t>& y_values,
           const std::vector<real_t>& y_error);
 
  void Add(const std::string& id, const std::vector<real_t>& x_values,
           const std::vector<real_t>& y_values,
           const std::vector<real_t>& y_error_low,
           const std::vector<real_t>& y_error_high);
 
  void Add(const TimeSeries& ts, const std::string& suffix);
 
  void AddTransformedData(const std::string& old_id,
                          const std::string& transformed_id,
                          const DataTransformer& transformer);
 
  void Update();
 
  bool Contains(const std::string& id) const;
  uint64_t Size() const;
  const std::vector<real_t>& GetXValues(const std::string& id) const;
  const std::vector<real_t>& GetYValues(const std::string& id) const;
  const std::vector<real_t>& GetYErrorLow(const std::string& id) const;
  const std::vector<real_t>& GetYErrorHigh(const std::string& id) const;
 
  void ListEntries() const;
 
  void Save(const std::string& full_filepath) const;
 
  void SaveJson(const std::string& full_filepath) const;
 
 private:
  std::unordered_map<std::string, Data> data_;
 
  BDM_CLASS_DEF_NV(TimeSeries, 1);
};
 
// The following custom streamer should be visible to rootcling for dictionary
// generation, but not to the interpreter!
#if (!defined(__CLING__) || defined(__ROOTCLING__)) && defined(USE_DICT)
 
// The custom streamer is needed because ROOT can't stream function pointers
// by default.
inline void TimeSeries::Data::Streamer(TBuffer& R__b) {
  if (R__b.IsReading()) {
    R__b.ReadClassBuffer(TimeSeries::Data::Class(), this);
    Long64_t l;
    R__b.ReadLong64(l);
    this->ycollector = reinterpret_cast<real_t (*)(Simulation*)>(l);
    R__b.ReadLong64(l);
    this->xcollector = reinterpret_cast<real_t (*)(Simulation*)>(l);
  } else {
    R__b.WriteClassBuffer(TimeSeries::Data::Class(), this);
    Long64_t l = reinterpret_cast<Long64_t>(this->ycollector);
    R__b.WriteLong64(l);
    l = reinterpret_cast<Long64_t>(this->xcollector);
    R__b.WriteLong64(l);
  }
}
 
#endif  // !defined(__CLING__) || defined(__ROOTCLING__)
 
}  // namespace experimental
}  // namespace bdm
 
#endif  // CORE_ANALYSIS_TIME_SERIES_H_