#ifndef __GMTMIRRORS_H_
#define __GMTMIRRORS_H_

#ifndef __RAYTRACING_H__
#include "rayTracing.h"
#endif

#ifndef __SOURCE_H__
#include "source.h"
#endif

__device__ rtd bending_modes_surface(vector *v, const int N_mode, rtd *b,
                                     double *BM,
                                     const int BM_N_SAMPLE, const double BM_radius);
__device__ rtd partial_x_bending_modes_surface(vector *v, const int N_mode, rtd *b,
                                               double *BM,
                                               const int BM_N_SAMPLE, const double BM_radius);
__device__ rtd partial_y_bending_modes_surface(vector *v, const int N_mode, rtd *b,
                                               double *BM,
                                               const int BM_N_SAMPLE, const double BM_radius);
__device__ rtd partial_z_bending_modes_surface(void);



struct bending_modes {
  double *d__x_BM, *d__y_BM;
  double *d__BM;
  double *d__BMS;
  double BM_radius;
  int BM_N_SAMPLE;
  double *d__BM_buffer;
  int n_mode;
  rtd *b, *d__b;
  int N;  
  void setup(int n_mode);
  void setup(int n_mode, int N_SET);
  void setupKL(int n_mode);
  void setupKL(int n_mode, int N_SET);
  void setupPolish(int n_mode, int N_SET);
  void cleanup(void);
  void load(void);
  void load_reg(void);
  void load_KL(void);
  void load_polish(void);
  void nearest_neighbor(rtd *d__BMi,
                   rtd *d__partial_x_BMi,
                   rtd *d__partial_y_BMi,
                   int NI, rtd di, int k_mode);
  void bilinear(rtd *d__BMi,
           rtd *d__partial_x_BMi,
           rtd *d__partial_y_BMi,
           int NI, rtd di, int k_mode);
  void update(rtd *b);
};
struct modes {
  double *d__x_BM, *d__y_BM;
  double *d__BM;
  double *d__BMS;
  double BM_radius;
  int BM_N_SAMPLE;
  double *d__BM_buffer;
  int n_mode;
  rtd *b, *d__b;
  int N;  
  char filename[256];
  int N_SET;
  int N_MODE;
  int *d__s2b;  
  void setup(char *filename, int N, int n_mode);
  void setup(int _BM_N_SAMPLE_, double _BM_radius_,
             int _N_SET_, int _N_MODE_, int *s2b,
             double *buffer, int _N_, int _n_mode_);
  void cleanup(void);
  void load(void);
  void load(int _BM_N_SAMPLE_, double _BM_radius_,
            int _N_SET_, int _N_MODE_, int *s2b,
            double *buffer);
  void reset_modes(double *buffer);
  void update(rtd *b);
};
struct gmt_m1 {
  int M_ID;
  rtd D_assembly;
  rtd D_clear;
  rtd D_full;
  rtd ri;
  rtd beta;
  rtd L;
    //rtd D;
    //int D_px;
  rtd area0, area_fraction;
  float area0_px;
  rtd area;
  int N;
  rtd depth;
  coordinate_system aperture_CS;
  coordinate_system conic_CS;
  vector conic_origin[7], *d__conic_origin;
  rtd conic_c, conic_k;
  rtd *d__conic_c, *d__conic_k;
  coordinate_system rigid_body_CS;
  coordinate_system motion_CS;
  rtd height;
  mask *V;
  int idx_offset;
  zernikeS *ZS;
  int *d__piston_mask;
  coordinate_system TT_CS;
  double *d__C, *d__D;
  cublasHandle_t handle;
  char *d__valid_segments;
    //bending_modes *BS;
  modes BS;
  float *d__segment_reflectivity;  
  
  void setup(void);
  //void setup(modes *_BS_);
  void setup(char *_filename_, int _N_, int _n_mode_);
  void setup(zernikeS *ZS);
  void cleanup(void);
  void update(vector _origin_, vector _euler_angles_,int idx);
  void reset(void);
  void trace(bundle *rays);
  void traceall(bundle *rays);
  void blocking(bundle *rays);
  void global_tiptilt(float tip, float tilt);
  void test_ray_tracing(void);
  void track(float *x, float *y, float *z, int N, int idx);
  void locate(float *x, float *y, float *z, int N, int idx);
  void remove(int *seg_ID, int N_ID);
  void keep(int *seg_ID, int N_ID);
  void update_conic_c(rtd *_conic_c_);
  void update_conic_k(rtd *_conic_k_);
  void set_reflectivity(float *reflectivity);
  void preset(bundle *rays, rtd margin);
  void edge_sensors_data(void);
};
struct gmt_m2 {
  int M_ID;
  rtd D_assembly;
  rtd D_clear;
  rtd D_full;
  rtd ri;
  rtd beta;
  rtd L;
    //rtd D;
    //int D_px;
  rtd area0, area_fraction;
  float area0_px;
  rtd area;
  int N;
  rtd depth;
  coordinate_system aperture_CS;
  coordinate_system conic_CS;
  vector conic_origin[7], *d__conic_origin;
  rtd conic_c, conic_k;
  rtd *d__conic_c, *d__conic_k;
  coordinate_system rigid_body_CS;
  coordinate_system motion_CS;
  rtd height;
  mask *V;
  int idx_offset;
  zernikeS *ZS;
  int *d__piston_mask;
  coordinate_system TT_CS;
  double *d__C, *d__D;
  cublasHandle_t handle;
  char *d__valid_segments;
    //bending_modes *BS;
  modes BS;
  float *d__segment_reflectivity;  
  void setup(void);
  //void setup(modes *_BS_);
  void setup(char *_filename_, int _N_, int _n_mode_);
  void setup(zernikeS *ZS);
  void cleanup(void);
  void update(vector _origin_, vector _euler_angles_,int idx);
  void reset(void);
  void trace(bundle *rays);
  void traceall(bundle *rays);
  void blocking(bundle *rays);
  void global_tiptilt(float tip, float tilt);
  void test_ray_tracing(void);
  void track(float *x, float *y, float *z, int N, int idx);
  void locate(float *x, float *y, float *z, int N, int idx);
  void remove(int *seg_ID, int N_ID);
  void keep(int *seg_ID, int N_ID);
  void update_conic_c(rtd *_conic_c_);
  void update_conic_k(rtd *_conic_k_);
  void set_reflectivity(float *reflectivity);
  void pointing_neutral(float tip, float tilt);
  void coma_neutral(float tip, float tilt);
};
struct stereoscopic_edge_sensors {
int N, N_DATA;
int n_byte, n_byte_DATA;
rtd alpha;
gmt_m1 *mirror;
vector *v0, *v, *d__v0, *d__v;
vector *dv0, *d__dv0;
vector *dv, *d__dv;
void setup(gmt_m1 *_mirror_);
void cleanup(void);
void data(void);
};
struct lateral_edge_sensors {
int N, N_DATA, N_HEIGHT;
rtd alpha;
rtd height;
gmt_m1 *mirror;
int n_byte_DATA;
rtd *x, *y, *d__x, *d__y, *d, *d__d;
vector *k_cam, *d__k_cam;
vector *k_laser, *d__k_laser;
vector *uP, *d__uP;
vector *vP, *d__vP;
vector *A, *A0, *B, *B0, *d__A, *d__A0, *d__B, *d__B0;
void setup(gmt_m1 *_mirror_);
void setup(gmt_m1 *_mirror_, rtd _height_);
void cleanup(void);
void data(void);
};

#endif // __GMTMIRRORS_H_