sutra_controller_generic_linear.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//  This file is part of COMPASS <https://anr-compass.github.io/compass/>
//
//  Copyright (C) 2011-2023 COMPASS Team <https://github.com/ANR-COMPASS>
//  All rights reserved.
 
// -----------------------------------------------------------------------------
 
 
#ifndef _SUTRA_CONTROLLER_GENERIC_LINEAR_H_
#define _SUTRA_CONTROLLER_GENERIC_LINEAR_H_
 
#include <sutra_acquisim.h>
#include <sutra_controller.h>
 
#include <memory>
 
template <typename Tcomp, typename Tout>
class sutra_controller_generic_linear : public SutraController<Tcomp, Tout> {
 
 
private:
  using SutraController<Tcomp,Tout>::nslopes; 
  using SutraController<Tcomp,Tout>::nactus;  
 
  bool m_polc;              
  bool m_modal;             
  int m_n_slope_buffers;    
  int m_n_states;           
  int m_n_state_buffers;    
  int m_n_modes;            
  int m_n_iir_in;           
  int m_n_iir_out;          
 
  using SutraController<Tcomp,Tout>::a; 
  using SutraController<Tcomp,Tout>::b; 
 
  using SutraController<Tcomp,Tout>::cublas_handle;
 
public:
 
  bool polc(){return m_polc;}
  bool modal(){return m_modal;}
  int n_slope_buffers(){return m_n_slope_buffers;}
  int n_states(){return m_n_states;}
  int n_state_buffers(){return m_n_state_buffers;}
  int n_modes(){return m_n_modes;}
  int n_iir_in(){return m_n_iir_in;}
  int n_iir_out(){return m_n_iir_out;}
 
  std::unique_ptr<CarmaObj<Tcomp>> d_x_now;   
  std::unique_ptr<CarmaObj<Tcomp>> d_s_now;   
  std::unique_ptr<CarmaObj<Tcomp>> d_u_now;   
 
  std::deque<CarmaObj<Tcomp> *> d_circular_x;     
  std::deque<CarmaObj<Tcomp> *> d_circular_s;     
  std::deque<CarmaObj<Tcomp> *> d_circular_u_in;  
  std::deque<CarmaObj<Tcomp> *> d_circular_u_out; 
 
  std::vector<CarmaObj<Tcomp>*> d_matA;      
  std::vector<CarmaObj<Tcomp>*> d_matL;      
  std::unique_ptr<CarmaObj<Tcomp>> d_matK;   
  std::unique_ptr<CarmaObj<Tcomp>> d_matD;   
  std::unique_ptr<CarmaObj<Tcomp>> d_matF;   
 
  std::vector<CarmaObj<Tcomp>*> d_iir_a;  
  std::vector<CarmaObj<Tcomp>*> d_iir_b;  
 
  using SutraController<Tcomp,Tout>::d_com;  
  using SutraController<Tcomp,Tout>::d_centroids;  
  using SutraController<Tcomp,Tout>::d_circular_coms; 
  using SutraController<Tcomp,Tout>::delay;
 
 public:
 sutra_controller_generic_linear() = delete;
  sutra_controller_generic_linear(
    CarmaContext *context, int nslope, int nslopes_buffers, int nactu, int nstates,
    int nstates_buffers, int nmodes, int niir_in, int niir_out,
    float delay, bool polc, bool is_modal,
    SutraDms *dms, int *idx_dms, int ndm, int *idx_centro, int ncentro);
  //sutra_controller_generic_linear(const sutra_controller_generic_linear &controller);
  ~sutra_controller_generic_linear();
 
  string get_type();
  string get_commandlaw();
  int set_matA(float * A, int i);
  int set_matL(float * L, int i);
  int set_matK(float * K);
  int set_matD(float * D);
  int set_matF(float * F);
  int set_iir_a(float * iir_a, int i);
  int set_iir_b(float * iir_b, int i);
  int set_polc(bool p);
  using SutraController<Tcomp,Tout>::comp_polc;
  int comp_polc();
  int comp_com();
 
  int recursion();
  int innovation();
  int modal_projection();
  int filter_iir_in();
  int filter_iir_out();
 
};
 
template <typename T>
void pad_cmat(T *idata, int m, int n, T *odata, int m2, int n2,
              CarmaDevice *device);
#endif  // _SUTRA_CONTROLLER_GENERIC_LINEAR_H_