ceo 0.1.0

CUDA Engined Optics
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

#ifndef __ATMOSPHERE_H__
#define __ATMOSPHERE_H__

#ifndef __UTILITIES_H__
#include "utilities.h"
#endif

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

#ifndef __CENTROIDING_H__
#include "centroiding.h"
#endif

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define handle_error(msg)                               \
  do { perror(msg); exit(EXIT_FAILURE); } while (0)

struct layer {

  float altitude;
  float xi0;
  float wind_speed, wind_direction, vx, vy;
  float WIDTH_LAYER, LENGTH_LAYER;
  int N_WIDTH_LAYER, N_LENGTH_LAYER;

  int setup(float _altitude, float _xi0,
            float _wind_speed_, float _wind_direction,
            float W, int N_W,
            float field_size,
            int OSF, float duration);

};

struct profile {

  float  L0;
  float l0, L, f, delta, N_k, N_a, kmin;
  float *altitude, *xi0, *wind_speed, *wind_direction;

  void setup(float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             int N_LAYER);
  void cleanup();

};

struct atmosphere {

  char *photometric_band;
  float wavelength, r0, wavenumber;
  int N_LAYER;
  float field_size;
  int layers_OSF;
  float layers_duration, layers_tau0;
  float W;
  int N_W;
  float *phase_screen_LAYER;
  int N_DURATION;
  int LOCAL_RAND_SEED;
  int ID;
  float EPH;
  float *d__phase_screen_LAYER;
  unsigned long N_PHASE_LAYER;
    //FILE *layers_fid;
  size_t mmap_size;
  float *zeta1, *eta1, *zeta2, *eta2;
  curandState *devStates;
  profile turbulence, *d__turbulence;
  layer *layers, *d__layers;

  void setup(float r0_, float L0, int N_LAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction);
  void setup(float r0_, float L0, int N_LAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             float _L_, int _NXY_PUPIL_,
             float field_size,
             float duration);
  void setup(float r0_, float L0, int _NLAYER,
             float *altitude, float *xi0,
             float *wind_speed, float *wind_direction,
             float _L_, int _NXY_PUPIL_,
             float field_size,
             float duration,
             const char *fullpath_to_phasescreens,
             int _N_DURATION);
  void gmt_setup();
  void gmt_setup(float r0_, float L0);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 const char *fullpath_to_phasescreens,
                 int _N_DURATION);
  void gmt_setup(float r0_, float L0,
                 int _RAND_SEED_);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 int _RAND_SEED_);
  void gmt_setup(float r0_, float L0,
                 float _L_, int _NXY_PUPIL_,
                 float field_size,
                 float duration,
                 const char *fullpath_to_phasescreens,
                 int _N_DURATION,
                 int _RAND_SEED_);
  void gmt_set_id(int _ID_);
  void gmt_set_eph(float _EPH_);

  void cleanup(void);

  void info(void);

  void reset(void);

  void save_layer_phasescreens(const char* fullpath_to_phasescreens, int _N_DURATION);

  void get_phase_screen(float *phase_screen,
                        float const *x, float const *y, int N_xy,
                        source *src, float time);

  void get_phase_screen(float const *x, float const *y, int N_xy,
                        source *src, float time);

  void get_phase_screen(float const delta_x, int N_x, float const delta_y, int N_y,
                        source *src, float time);

  void get_phase_screen(float *phase_screen,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        source *src, float time);
  void get_phase_screen(source *src,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time);
  void get_phase_screen(source *src,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time, float exponent);
  void get_phase_screen(source *src, int N_SRC,
                        float const delta_x, int N_x, float const delta_y, int N_y,
                        float time);
  void get_phase_screen(source *src, float time);

  void get_phase_screen_gradient(float *sx, float *sy, float *x, float *y, int Nxy, source *src, float time);
  void get_phase_screen_gradient(float *sx, float *sy, int NL,
                                 float const d, source *src, float time);
  void get_phase_screen_gradient(float *sx, float *sy, int NL,
                                 char *valid_lenslet, float const d, source *src, float time);
  void get_phase_screen_gradient(centroiding *cog, int NL,
                                 float const d, source *src, float time);
  void get_phase_screen_gradient_rolling_shutter(centroiding *cog, int NL,
                                                 float const d, source *src, float time, float delay);
  void get_phase_screen_gradient(centroiding *cog, int NL,
                                 float const d, source *src, int N_SRC, float time);
  void get_phase_screen_gradient(centroiding *cog, int NL, char *valid_lenslet,
                                 float const d, source *src, int N_SRC, float time);
  void get_phase_screen_circ_centroids(centroiding *cog, const float R,
                                       source *src, int N_SRC, float time);
  void get_phase_screen_circ_uplink_centroids(centroiding *cog, const float R,
                                              source *src, int N_SRC, float time,
                                              char focused);

  void rayTracing(const float* x_PUPIL,const float* y_PUPIL,
                  float* phase_screen_PUPIL, const int NXY_PUPIL,
                  const source* src, const float tau);
  void rayTracing(source *src,
                  const float delta_x, const int N_X,
                  const float delta_y, const int N_Y,
                  const float tau);
};

#endif // __ATMOSPHERE_H__