ces.hpp

Go to the documentation of this file.

#ifndef EXPLICIT_MAPMAKING_CES_HPP_
#define EXPLICIT_MAPMAKING_CES_HPP_

#include "filters.hpp"
#include <vector>
#include <list>
#include <stdio.h>

namespace mapmaking {

struct Subscan {  // TODO move it elsewhere
  Subscan(int in_idx, int in_t_first, int in_n_sample, Filters& filters) 
      : legendre_(filters.ConcatenetedLegendre(in_n_sample))  {
    idx = in_idx;
    t_first = in_t_first;
    n_sample = in_n_sample;
    t_last = in_t_first + in_n_sample - 1;
  }
  int idx;
  int t_first;
  int t_last;
  int n_sample;
  const std::vector<double>& legendre_;
  double Legendre(int order, int i_sample) const { return legendre_[i_sample + order * n_sample]; }
};

class CES {
  friend class IOManager;
 public:
  CES(int n_sample, Filters& filters);
  CES(int n_sample, const double* data, const double* pol_angle, const int* pixel, const int* ground, double weight, Filters& filters);
  int ComputeKernel(double threshold=1e-6);
  void WhiteNoise();

  void AddSubscan(int t_first, int n_sample);
  void ChangePixelIndexes(const std::vector<int>& old2new);
  int id() const { return id_; }
  double weight() const { return weight_; }
  double data(int t) const { return data_[t]; }
  double data(int t, const std::vector<double>& map) const { return cos_[t] * map[2 * pixel_[t]] + sin_[t] * map[2 * pixel_[t] + 1]; }
  double cos(int t) const { return cos_[t]; }  // cos(2 * phi); phi = pol angle
  double sin(int t) const { return sin_[t]; }
  int pixel(int t) const { return pixel_[t]; }
  int n_pol() const { return n_pol_; }
  int n_gt() const { return n_gt_; }
  int n_sub() const { return subscans_.size(); }
  int n_filters() const { return n_filters_; }
  double kernel(int idx) const { return kernel_[idx]; }
  double ground(int t) const { return ground_[t]; }
  void ApplyKernel(std::vector<double>* vec); 
  int CompressTimeStreams(); // TODO test and assess the gain 
  const std::list<Subscan>& subscans() const { return subscans_; };

 private:
  std::list<Subscan> subscans_;
  double weight_ = 0;
  int id_ = 0;  // common to all the bolometers in the same CES
  std::vector<double> data_;
  std::vector<double> cos_;
  std::vector<double> sin_;
  std::vector<int> pixel_;
  std::vector<int> ground_;
  std::vector<double> kernel_;  // Orthonormalization kernel
  Filters& filters_;  // Contains the polynomial filters, shared by many ces instances
  int n_filters_ = 0;  // Both ground template and polynomial
  int n_gt_;
  int n_pol_;
  void AllocateVectors(int n_sample);
  void CosSinFromPolAngle(const std::vector<double>& pol_angle);
};
}

#endif  // EXPLICIT_MAPMAKING_CES_HPP_