31 for (
int i=0 ; i<6; i++ ) {
40 for (
int i=0 ; i<6; i++ ) {
50 cpl_table * spectrum_table, * detector_table, * wavelength_table;
51 char * polarisation, * data_x;
53 cpl_propertylist * primary_hdr;
54 int type_data, pol, npol, nregion, reg, nwave, size, wave, nv;
58 for (type_data = 0; type_data < 2; type_data ++) {
79 if ((spectrum_table == NULL) || (primary_hdr == NULL) ||
80 (wavelength_table == NULL) || (detector_table == NULL)){
82 return cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
83 "The preproc data must contrain "
84 "SPECTRUM_DATA field");
89 nwave = cpl_table_get_column_dimension(spectrum_table,
"DATA1", 1);
90 size = cpl_table_get_column_dimension(spectrum_table,
"DATA1", 0);
92 nregion = cpl_table_get_nrow(detector_table);
100 GRAVI_OI_WAVE_EXT(type_data),
103 for (pol = 0; pol < npol; pol++){
115 cpl_image * mean_pol = cpl_image_new(size, nwave, CPL_TYPE_DOUBLE);
116 cpl_image_fill_window (mean_pol, 1, 1, size, nwave, 0.0);
118 for (reg = 0; reg < nregion; reg ++){
120 regname = cpl_table_get_string (detector_table,
"REGANAME", reg);
122 if (!strstr(regname, polarisation))
126 data_x = cpl_sprintf(
"DATA%d", reg+1);
128 cpl_imagelist * spec_data = gravi_table_data_to_imagelist(
129 spectrum_table, reg+1);
131 cpl_image * mean_spec = cpl_imagelist_collapse_create(spec_data);
133 cpl_image_add (mean_pol, mean_spec);
134 cpl_imagelist_delete (spec_data);
140 double val_spec = cpl_image_get (mean_pol, 1, 1, &nv);
141 for (wave = 1; wave < nwave; wave ++){
142 if (val_spec < cpl_image_get (mean_pol, 1, wave, &nv)){
143 val_spec = cpl_image_get (mean_pol, 1, wave, &nv);
149 float wave_lazer = cpl_table_get_float (wavelength_table,
150 "EFF_WAVE", ind, &nv);
151 char * key = cpl_sprintf(
"LASER %s %s",
GRAVI_TYPE(type_data), polarisation);
152 cpl_propertylist_append_float (primary_hdr, key, wave_lazer);
161 return CPL_ERROR_NONE;
167 cpl_table * vistable_sc, * wavelenght_sc, * fddl_met;
168 cpl_propertylist *
plist, * vis_FT_p, * vis_SC_p, * wavesc_plist;
170 int wave, nwave_sc, base, nbase = 6, row , nfile, nv;
171 cpl_array * phase_sc_base;
172 const cpl_array * phase_sc,
173 * phase_met1, * phase_met2, * fddl_sc, * fddl_ft;
174 cpl_vector * wave_sc;
175 cpl_bivector * fout, * fref;
176 int tel_1[6] = {0,0,0,1,1,2}, pol = 0;
177 int tel_2[6] = {1,2,3,2,3,3}, size_matrix, size_opd, npol;
178 double pos_sc, pos_ft, pos_mean, ph_sc, opd_sc, opd_met,
180 double time_sc, time_ft, exptime_sc;
181 gsl_matrix * phase_disp;
182 gsl_vector ** opd_disp;
183 char * pol_FT_check[2], * pol_SC_check[2];
222 nfile=cpl_table_get_nrow(fddl_met);
230 for (pol = 0; pol < npol; pol ++){
232 GRAVI_OI_VIS_SC_EXT, pol_SC_check[pol]);
234 GRAVI_OI_WAVELENGTH_SC_EXT, pol_SC_check[pol]);
236 GRAVI_OI_WAVELENGTH_SC_EXT, pol_SC_check[pol]);
237 nwave_sc = gravi_pfits_get_nwave (wavesc_plist);
238 wave_sc = cpl_vector_new(nwave_sc);
252 nfile = cpl_table_get_nrow (vistable_sc) / 6;
257 phase_disp = gsl_matrix_calloc (nfile * 6, 8);
259 opd_disp = cpl_malloc(nwave_sc *
sizeof(gsl_vector *));
260 for (wave = 0; wave < nwave_sc; wave ++){
262 cpl_vector_set (wave_sc, wave,
263 cpl_table_get_float (wavelenght_sc,
"EFF_WAVE", wave, &nv));
264 opd_disp[wave] = gsl_vector_alloc (nfile * 6);
268 cpl_array * met_phase = cpl_array_new(4, CPL_TYPE_DOUBLE);
269 cpl_array_fill_window (met_phase, 0, 4, 0.0);
270 for (row = 0; row < cpl_table_get_nrow(fddl_met); row ++){
271 cpl_array_add (met_phase, cpl_table_get_array(fddl_met,
"PHASE_FC", row));
274 cpl_array_divide_scalar(met_phase, cpl_table_get_nrow(fddl_met));
276 for (base = 0; base < 6; base++){
278 ph_met1 = cpl_array_get_double (met_phase, tel_1[base], &nv);
279 ph_met2 = cpl_array_get_double (met_phase, tel_2[base], &nv);
280 opd_met = (ph_met1 - ph_met2) * 2 * M_PI *
LAMBDA_MET;
288 for (row = 0; row < nfile; row ++){
292 phase_sc = cpl_table_get_array (vistable_sc,
"VISPHI", row * 6 + base);
299 phase_sc_base = cpl_array_duplicate (phase_sc);
301 if (cpl_error_get_code()){
302 cpl_bivector_unwrap_vectors(fout);
303 cpl_bivector_unwrap_vectors(fref);
304 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
305 "Error during the interpolation of phase ft");
310 fddl_sc = cpl_table_get_array (fddl_met,
"FT_POS", row);
311 fddl_ft = cpl_table_get_array (fddl_met,
"SC_POS", row);
312 pos_sc = cpl_array_get_float (fddl_sc, tel_1[base], &nv);
313 pos_ft = cpl_array_get_float (fddl_ft, tel_1[base], &nv);
315 pos_mean = (pos_sc + pos_ft) / 2;
316 gsl_matrix_set (phase_disp, row * nbase + base, tel_1[base], ph_met1);
317 gsl_matrix_set (phase_disp, row * nbase + base, tel_2[base], ph_met2);
318 gsl_matrix_set (phase_disp, row * nbase + base, 4 + tel_1[base], pos_mean);
320 pos_sc = cpl_array_get_float (fddl_sc, tel_2[base], &nv);
321 pos_ft = cpl_array_get_float (fddl_ft, tel_2[base], &nv);
323 pos_mean = (pos_sc + pos_ft) / 2;
325 gsl_matrix_set (phase_disp, row * nbase + base, 4 + tel_2[base], pos_mean);
328 for (wave = 0; wave < nwave_sc; wave++){
329 ph_sc = cpl_array_get_double (phase_sc_base, wave, &nv);
330 opd_sc = ph_sc * cpl_vector_get (wave_sc, wave)/ (2 * M_PI);
334 gsl_vector_set (opd_disp[wave], base + nbase * row,
340 if (cpl_error_get_code()){
341 cpl_bivector_unwrap_vectors(fout);
342 cpl_bivector_unwrap_vectors(fref);
343 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
344 "Error during the construction of the opd vector");
348 cpl_array_delete (phase_sc_base);
353 cpl_vector_unwrap (wave_sc);
354 cpl_array_delete (met_phase);
355 cpl_table * disp_table = cpl_table_new (nwave_sc);
356 cpl_table_new_column_array (disp_table,
"COEFF",
363 gsl_matrix * u = gsl_matrix_calloc (nfile * 6, 8), * V;
366 for (wave = 0; wave < nwave_sc; wave ++){
368 gsl_matrix_memcpy(u, phase_disp);
369 x = gsl_vector_alloc (8);
370 work = gsl_vector_alloc (8);
371 S = gsl_vector_alloc (8);
372 coeff = cpl_array_new (8, CPL_TYPE_DOUBLE);
373 V = gsl_matrix_alloc (8, 8);
375 gsl_linalg_SV_decomp (u, V, S, work);
376 gsl_linalg_SV_solve (u, V, S, opd_disp[wave], x);
378 for (i = 0; i < 8; i ++) {
379 cpl_array_set_double (coeff, i, gsl_vector_get (x, i));
382 cpl_table_set_array (disp_table,
"COEFF", wave, coeff);
384 cpl_array_delete (coeff);
385 gsl_vector_free (opd_disp[wave]);
388 gsl_vector_free (work);
392 gsl_matrix_free (phase_disp);
396 cpl_propertylist * met_plist = cpl_propertylist_duplicate (wavesc_plist);
397 char * name_tb = cpl_sprintf(
"DISP_%s", pol_SC_check[pol]);
398 cpl_propertylist_append_string (met_plist,
"EXTNAME",
401 gravi_data_add (disp_data, met_plist, disp_table);
402 cpl_propertylist_delete (met_plist);
435 cpl_propertylist * primary_hdr, *
plist;
436 cpl_table * spectrum_table, * imaging_detector, *
wave_data_sc,
438 cpl_matrix * all_coord;
439 cpl_array * wavelength;
440 cpl_polynomial * fit2d;
441 cpl_vector * residuals;
444 const cpl_size deg2d[2] = {2, 2};
445 const cpl_size deg1d[1] = {2};
446 cpl_vector * coord_X, * coord_Y, * all_wavelength;
451 int nwave, n_region, region;
456 double minwave = 0, maxwave = 1e10;
457 cpl_image * img_profile, * image_wave, * profile_image;
458 cpl_imagelist * imglist_wave;
459 cpl_table * profile_table;
460 cpl_table * wave_fibre;
461 int sizey, sizex, ind;
464 if (argon_data == NULL){
465 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"The data is NULL");
472 cpl_image * img_median = cpl_imagelist_collapse_median_create (imglist);
474 cpl_imagelist * imglist_med = cpl_imagelist_new ();
475 cpl_imagelist_set (imglist_med, img_median, 0);
481 dark_map, bad_map, NULL);
484 cpl_msg_info (cpl_func,
"Execution time gravi_extract_spectrum : %f", (end - start) / (
double)CLOCKS_PER_SEC);
490 double line_wave[] = {
510 if ((spectrum_table == NULL) || (imaging_detector == NULL)) {
512 cpl_error_set_message(cpl_func,
513 CPL_ERROR_ILLEGAL_OUTPUT,
"Data must contain SPECTRUM_DATA");
518 double wavestep = cpl_array_get_double (cpl_table_get_array (
wave_data_sc,
"DATA1", 0), 1, &nv) -
519 cpl_array_get_double (cpl_table_get_array (
wave_data_sc,
"DATA1", 0), 0, &nv);
521 cpl_array ** wave_array;
537 nwave = cpl_table_get_column_dimension(spectrum_table,
"DATA1", 1);
538 n_region = cpl_table_get_nrow(imaging_detector);
541 coord_X = cpl_vector_new(n_region * nlines);
542 coord_Y = cpl_vector_new(n_region * nlines);
543 cpl_vector * coord_X_fit = cpl_vector_new(n_region * nlines);
544 all_wavelength = cpl_vector_new(n_region * nlines);
545 cpl_vector * fitsigm = cpl_vector_new(n_region * nlines);
547 cpl_vector_fill (coord_X, -1);
548 cpl_vector_fill (coord_Y, -1);
549 cpl_vector_fill (all_wavelength, -1);
551 int fitwidth, fit_in, comp = 0, list;
556 if (! (strcmp(resolution,
"LOW") && strcmp(resolution,
"MED")) )
563 const cpl_array * argon;
565 for (region = 0; region < n_region; region ++) {
567 data_x = cpl_sprintf(
"DATA%d", region + 1);
568 wave_array = cpl_table_get_data_array (
wave_data_sc, data_x);
569 wave_ = cpl_array_get_data_double (wave_array[0]);
571 for (wave = 0; wave < nwave; wave ++){
572 wave_ [wave] -= wave * wavestep * slope;
575 argon = cpl_table_get_array (spectrum_table, data_x, 0);
580 for (list = 0; list < nlines; list ++) {
582 while (wave_[wave] < line_wave[list]){
589 cpl_error_set_message(cpl_func,
590 CPL_ERROR_ILLEGAL_OUTPUT,
"The argon wavelength does "
591 "not much with the calibration wavelength ");
596 double coord_flux = 0, coord_err = 0;
597 cpl_vector * vector_x=cpl_vector_new(fitwidth*2);
598 cpl_vector * vector_y=cpl_vector_new(fitwidth*2);
600 for (fit_in = wave - fitwidth; fit_in < wave + fitwidth; fit_in ++){
601 cpl_vector_set(vector_x, i, fit_in);
602 cpl_vector_set(vector_y, i, cpl_array_get_double (argon, fit_in, &nv));
604 flux += cpl_array_get_double (argon, fit_in, &nv);
605 coord_flux += fit_in * cpl_array_get_double (argon, fit_in, &nv);
609 cpl_errorstate prestate = cpl_errorstate_get();
610 double x0, sigma, area, offset, mse;
611 cpl_vector_fit_gaussian (vector_x, NULL, vector_y, NULL,
612 CPL_FIT_ALL, &x0, &sigma, &area,
613 &offset, &mse, NULL, NULL);
615 coord_flux = (coord_flux / flux);
616 coord_err = fabs (flux);
619 if (cpl_error_get_code() == CPL_ERROR_CONTINUE){
620 cpl_errorstate_set (prestate);
621 cpl_msg_warning(cpl_func,
"The gaussian fit did not converge while fitting argon line");
630 cpl_vector_set (coord_X, list * n_region + region, x0);
631 cpl_vector_set (coord_Y, list * n_region + region, region + 1);
633 cpl_vector_set (fitsigm, list * n_region + region, sigma);
634 cpl_vector_set (all_wavelength, list * n_region + region, line_wave[list]);
645 cpl_vector * coord_x_list, * fitsigm_list,
646 * coord_y_list, * coord_x_fit = cpl_vector_new (n_region);
648 cpl_matrix * matrix3, * matrix2;
650 gsl_matrix * X = gsl_matrix_alloc (n_region, 3);
651 gsl_matrix * X_bis = gsl_matrix_alloc (n_region, 3);
652 gsl_vector * y = gsl_vector_alloc (n_region);
653 gsl_vector * w = gsl_vector_alloc (n_region);
655 gsl_vector * c = gsl_vector_alloc (3);
656 gsl_matrix * cov = gsl_matrix_alloc (3, 3);
657 double chisq, result_gsl;
660 for (list = 0; list < nlines; list++) {
662 coord_x_list = cpl_vector_extract (coord_X, list * n_region, (list + 1) * n_region - 1, 1);
663 fitsigm_list = cpl_vector_extract (fitsigm, list * n_region, (list + 1) * n_region - 1, 1);
664 coord_y_list = cpl_vector_extract (coord_Y, list * n_region, (list + 1) * n_region - 1, 1);
666 for (i = 0; i < n_region; i++){
667 gsl_matrix_set (X, i, 0, 1.0);
668 gsl_matrix_set (X, i, 1, cpl_vector_get (coord_y_list, i));
669 gsl_matrix_set (X, i, 2, cpl_vector_get (coord_y_list, i) *
670 cpl_vector_get (coord_y_list, i));
672 gsl_vector_set (y, i, cpl_vector_get (coord_x_list, i));
673 gsl_vector_set (w, i, cpl_vector_get (fitsigm_list, i));
676 gsl_matrix_memcpy (X_bis, X);
677 gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n_region, 3);
678 gsl_multifit_wlinear (X_bis, w, y, c, cov,
680 gsl_multifit_linear_free (work);
682 CPLCHECK_NUL(
"Cannot compute the barycneter of all regions");
684 for (region = 0; region < n_region; region ++){
686 result_gsl = gsl_vector_get (c, 0) + gsl_vector_get (c, 1) *
687 gsl_matrix_get (X, region, 1) + gsl_vector_get (c, 2) *
688 gsl_matrix_get (X, region, 2);
689 cpl_vector_set (coord_X_fit, list * n_region + region, result_gsl);
690 cpl_vector_set (coord_x_fit, region, result_gsl);
693 cpl_vector_delete (coord_x_list);
694 cpl_vector_delete (fitsigm_list);
695 cpl_vector_delete (coord_y_list);
699 gsl_matrix_free (cov);
701 gsl_matrix_free (X_bis);
706 cpl_vector_delete (coord_x_fit);
711 fit2d = cpl_polynomial_new(2);
713 matrix3 = cpl_matrix_wrap(1, nlines * n_region, cpl_vector_get_data(coord_X));
714 matrix2 = cpl_matrix_wrap(1, nlines * n_region, cpl_vector_get_data(coord_Y));
716 all_coord = cpl_matrix_duplicate (matrix3) ;
717 cpl_matrix_append(all_coord, matrix2, 1);
720 cpl_polynomial_fit(fit2d, all_coord, NULL, all_wavelength, NULL,
721 CPL_TRUE, NULL, deg2d);
722 residuals = cpl_vector_new(nlines*n_region);
723 cpl_vector_fill_polynomial_fit_residual (residuals, all_wavelength, NULL,
724 fit2d, all_coord, &rechisq );
727 X = gsl_matrix_alloc (n_region*nlines, 6);
728 X_bis = gsl_matrix_alloc (n_region*nlines, 6);
729 y = gsl_vector_alloc (n_region*nlines);
730 w = gsl_vector_alloc (n_region*nlines);
732 c = gsl_vector_alloc (6);
733 cov = gsl_matrix_alloc (6, 6);
735 for (list = 0; list < nlines; list++) {
737 coord_x_list = cpl_vector_extract (coord_X, list * n_region, (list + 1) * n_region - 1, 1);
738 fitsigm_list = cpl_vector_extract (fitsigm, list * n_region, (list + 1) * n_region - 1, 1);
739 coord_y_list = cpl_vector_extract (coord_Y, list * n_region, (list + 1) * n_region - 1, 1);
741 for (i = 0; i < n_region; i++){
742 gsl_matrix_set (X, i+list*n_region, 0, 1.0);
743 gsl_matrix_set (X, i+list*n_region, 1, cpl_vector_get (coord_x_list, i));
744 gsl_matrix_set (X, i+list*n_region, 2, cpl_vector_get (coord_x_list, i) *
745 cpl_vector_get (coord_x_list, i));
746 gsl_matrix_set (X, i+list*n_region, 3, cpl_vector_get (coord_y_list, i));
747 gsl_matrix_set (X, i+list*n_region, 4, cpl_vector_get (coord_y_list, i) *
748 cpl_vector_get (coord_y_list, i));
749 gsl_matrix_set (X, i+list*n_region, 5, cpl_vector_get (coord_x_list, i) *
750 cpl_vector_get (coord_y_list, i));
752 gsl_vector_set (y, i+list*n_region, line_wave[list]);
753 gsl_vector_set (w, i+list*n_region, 1./pow(cpl_vector_get (fitsigm_list, i),2));
757 gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n_region*nlines, 6);
758 gsl_matrix_memcpy (X_bis, X);
759 gsl_multifit_wlinear (X_bis, w, y, c, cov,
761 gsl_vector * r=gsl_vector_alloc (n_region*nlines);
762 gsl_multifit_linear_residuals (X_bis, y, c, r);
763 gsl_multifit_linear_free (work);
765 for (list = 0; list < nlines; list++) {
766 for (i = 0; i < n_region; i++){
773 CPLCHECK_NUL(
"Error in the fit of the wavelength and position");
801 cpl_vector_delete(coord_X_fit);
802 cpl_vector_delete(all_wavelength);
803 cpl_vector_delete(coord_X);
804 cpl_vector_delete(coord_Y);
805 cpl_matrix_delete (all_coord);
806 cpl_matrix_unwrap(matrix2);
807 cpl_matrix_unwrap(matrix3);
808 cpl_vector_delete(residuals);
809 cpl_vector_delete(fitsigm);
815 cpl_array * dimension = cpl_array_new(2, CPL_TYPE_INT);
816 cpl_array_set(dimension, 0, 1);
817 cpl_array_set(dimension, 1, nwave);
820 sizex = cpl_table_get_column_dimension (profile_table,
"DATA1", 0);
821 sizey = cpl_table_get_column_dimension (profile_table,
"DATA1", 1);
822 profile_image = cpl_image_new (sizex, sizey, CPL_TYPE_DOUBLE);
823 cpl_image_fill_window (profile_image, 1, 1, sizex, sizey, 0.0);
824 image_wave = cpl_image_new (sizex, sizey, CPL_TYPE_DOUBLE);
825 cpl_image_fill_window (image_wave, 1, 1, sizex, sizey, 0.0);
827 img_output = cpl_table_new (1);
829 for (region = 0 ; region < n_region; region ++) {
831 data_x = cpl_sprintf(
"DATA%d", region + 1);
833 imglist_wave = gravi_table_data_to_imagelist(profile_table, region + 1);
834 img_profile = cpl_imagelist_get(imglist_wave, 0);
836 cpl_table_new_column_array (img_output, data_x, CPL_TYPE_DOUBLE, nwave);
837 cpl_table_set_column_dimensions(img_output, data_x, dimension);
839 wavelength = cpl_array_new(nwave, CPL_TYPE_DOUBLE);
844 cpl_image_add (profile_image, img_profile);
845 pos = cpl_vector_new(2);
846 for (wave = 0; wave < nwave; wave ++) {
848 cpl_vector_set(pos, 0, wave);
849 cpl_vector_set(pos, 1, region + 1);
850 result=gsl_vector_get (c, 0) +
851 gsl_vector_get (c, 1) * wave +
852 gsl_vector_get (c, 2) * wave*wave +
853 gsl_vector_get (c, 3) * (region+1) +
854 gsl_vector_get (c, 4) * (region+1)*(region+1) +
855 gsl_vector_get (c, 5) * (region+1)*wave;
859 cpl_array_set(wavelength, wave, result);
862 for (ind = 0; ind < sizey; ind ++){
864 if (cpl_image_get (img_profile, wave+1, ind+1, &nv) > 0.01)
865 cpl_image_set (image_wave, wave+1, ind+1, result);
870 cpl_vector_delete(pos);
873 minwave = CPL_MAX (minwave, cpl_array_get_min(wavelength));
874 maxwave = CPL_MIN (maxwave, cpl_array_get_max(wavelength));
876 cpl_table_set_array(img_output, data_x, 0, wavelength);
878 cpl_imagelist_delete (imglist_wave);
879 cpl_array_delete(wavelength);
889 gravi_data_append_header (wave_map,
plist);
891 cpl_propertylist * img_plist;
893 for (ext = 0; ext < nb_ext; ext++ ){
903 if (!(strcmp (plist_name,
"WAVE_FIBRE_SC") &&
906 strcmp (plist_name,
"TEST_WAVE"))){
909 gravi_data_add (wave_map, img_plist,
917 else if (type_ext == 3)
925 cpl_propertylist_append_double (primary_hdr, QC_MINWAVE_SC, minwave);
926 cpl_propertylist_append_double (primary_hdr, QC_MAXWAVE_SC, maxwave);
927 cpl_msg_info (cpl_func,
"QC_MINWAVE_SC = %e QC_MAXWAVE_SC = %e", minwave, maxwave);
933 imglist_wave = cpl_imagelist_new ();
934 cpl_imagelist_set(imglist_wave, image_wave, 0);
935 cpl_imagelist_set(imglist_wave, profile_image, 1);
937 gravi_data_set_cube (wave_map,
"TEST_WAVE", imglist_wave);
939 cpl_polynomial_delete (fit2d);
940 cpl_array_delete (dimension);
949 cpl_propertylist * primary_hdr, *
plist, * wavePlist, * detectorPlist;
950 cpl_table * detector, * waveArgon_table, * waveData_table,
952 cpl_matrix * all_coord;
953 cpl_array * wavelength;
954 cpl_polynomial * fit_slope;
955 cpl_polynomial * fit2d;
956 cpl_vector * residuals;
959 const cpl_size deg2d[2] = {4, 4};
960 cpl_vector * coord_X, * coord_Y, * all_wavelength;
965 int nwave, n_region, region;
971 double minwave, maxwave;
972 cpl_image * image_wave;
973 cpl_imagelist * imglist_wave;
974 int sizey, sizex, ind, npol;
978 char * baseString [6] = {
"12",
"13",
"14",
"23",
"24",
"34"};
979 char * baseString_bis [6] = {
"21",
"31",
"41",
"32",
"42",
"43"};
980 const cpl_size deg = 0, degM = 1;
981 cpl_vector * position;
982 cpl_matrix * matFit2;
985 if ((argon_wave == NULL) || (
wave_data == NULL)){
986 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
991 int nbase = 6, base, type_data;
996 if (strcmp(resolArg, resolWave)){
997 cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
998 "The argon file doesn t have the same"
999 "resultion as the input wave");
1011 n_region = cpl_table_get_nrow (detector) ;
1013 npol = (n_region > 24)?2:1;
1021 nwave = cpl_table_get_column_depth(waveArgon_table,
"DATA1");
1022 char * base_fiber = cpl_sprintf(
"BASE_12_%s", pola);
1023 if (nwave!= cpl_table_get_column_depth(waveData_table, base_fiber)){
1024 cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1025 "The argon and the wave data do not have"
1026 " the same number of wavelength");
1033 cpl_image * img_profile = cpl_imagelist_get (imglist, 1);
1034 sizex = cpl_image_get_size_x (img_profile);
1035 sizey = cpl_image_get_size_y (img_profile);
1036 image_wave = cpl_image_new (sizex, sizey, CPL_TYPE_DOUBLE);
1037 cpl_image * image_real = cpl_image_new (sizex, sizey, CPL_TYPE_DOUBLE);
1038 cpl_image_fill_window (image_real, 1, 1, sizex, sizey, 0.0);
1039 matFit2 = cpl_matrix_new (2,n_region*nwave);
1040 all_wavelength = cpl_vector_new (n_region*nwave);
1041 int regionA, regionD, regionC, regionB;
1042 cpl_array * waveToCal;
1044 cpl_table * cooef_table = cpl_table_new (n_region);
1045 cpl_table_new_column(cooef_table,
"SLOPE", CPL_TYPE_DOUBLE);
1046 cpl_table_new_column(cooef_table,
"OFFSET", CPL_TYPE_DOUBLE);
1050 if (cpl_error_get_code ()){
1051 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"Problem to get "
1052 "the start window detector");
1056 cpl_vector * vect_index = cpl_vector_new (nwave), * vect;
1058 for (i = startx; i < startx + nwave; i++){
1061 cpl_vector_set (vect_index, i - startx, 0);
1065 cpl_vector_set (vect_index, i - startx, 1);
1069 cpl_vector * residual_p = cpl_vector_new(np * n_region),
1070 * residual_q = cpl_vector_new(nq * n_region);
1072 for (region = 0; region < n_region; region ++) {
1169 const char * regname = cpl_table_get_string (detector,
"REGNAME", region);
1170 for (base = 0; base < nbase; base++){
1173 if (strstr(regname, baseString[base]) ||
1174 strstr(regname, baseString_bis[base]))
1179 if (strstr (regname,
POLAR_1))
1185 base_fiber = cpl_sprintf (
"BASE_%s_%s", baseString[base], pola);
1186 data_x = cpl_sprintf (
"DATA%d", region + 1);
1187 wavelength = cpl_array_duplicate (cpl_table_get_array (waveData_table,
1189 waveToCal = cpl_array_duplicate (wavelength);
1190 cpl_array_subtract (wavelength, cpl_table_get_array (waveArgon_table,
1195 cpl_matrix * matrix = cpl_matrix_new (1, nwave);
1196 position = cpl_vector_wrap (nwave, cpl_array_get_data_double(wavelength));
1198 for (ind = 0; ind < nwave; ind++) {
1199 cpl_matrix_set (matFit2,0, region*nwave + ind,
1201 cpl_matrix_set (matFit2,1, region*nwave + ind,
1203 cpl_matrix_set(matrix, 0, ind, ind);
1215 fit_slope = cpl_polynomial_new(1);
1216 cpl_polynomial_fit(fit_slope, matrix, NULL, position, NULL,
1217 CPL_FALSE, °, °M);
1219 vect = cpl_vector_new (nwave);
1220 cpl_vector_fill_polynomial_fit_residual (vect, position, NULL,
1221 fit_slope, matrix, &rechisq );
1222 if (cpl_error_get_code ()){
1223 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"fit the residual");
1229 for (wave = 0; wave < nwave; wave ++)
1230 if (cpl_vector_get (vect_index, wave) == 0) {
1231 cpl_vector_set (residual_p, ip + np * region ,
1232 cpl_vector_get (vect, wave));
1236 cpl_vector_set (residual_q, iq + nq * region,
1237 cpl_vector_get (vect, wave));
1243 const cpl_size pow_slope = 1;
1244 const cpl_size pow_slope2 = 0;
1245 cpl_msg_info (cpl_func,
"region %s : y = %e * x + %e", regname,
1246 cpl_polynomial_get_coeff(fit_slope,&pow_slope ),
1247 cpl_polynomial_get_coeff(fit_slope,
1250 cpl_table_set_double (cooef_table,
"SLOPE", region,
1251 cpl_polynomial_get_coeff(fit_slope,&pow_slope ));
1252 cpl_table_set_double (cooef_table,
"OFFSET", region,
1253 cpl_polynomial_get_coeff(fit_slope,&pow_slope2 ));
1254 if (cpl_error_get_code()){
1256 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"fit slope");
1260 pos = cpl_vector_new (1);
1261 for (wave = 0; wave < nwave; wave++){
1262 cpl_vector_set (pos, 0, wave);
1263 cpl_vector_set(all_wavelength, region*nwave + wave,
1264 cpl_array_get_double (waveToCal, wave, &nv) -
1265 cpl_polynomial_eval(fit_slope, pos));
1268 cpl_vector_delete (pos);
1269 cpl_polynomial_delete (fit_slope);
1270 cpl_matrix_delete (matrix);
1271 cpl_vector_unwrap (position);
1272 cpl_array_delete(wavelength);
1273 cpl_array_delete(waveToCal);
1275 cpl_free (base_fiber);
1279 double step = cpl_vector_get_median (residual_p) - cpl_vector_get_median (residual_q);
1285 fit2d = cpl_polynomial_new(2);
1286 cpl_polynomial_fit(fit2d, matFit2, NULL, all_wavelength, NULL,
1287 CPL_TRUE, NULL, deg2d);
1288 cpl_matrix_delete (matFit2);
1290 if (cpl_error_get_code()){
1292 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"fit 2D");
1300 cpl_array * dimension = cpl_array_new(2, CPL_TYPE_INT);
1301 cpl_array_set(dimension, 0, 1);
1302 cpl_array_set(dimension, 1, nwave);
1304 cpl_image_fill_window (image_wave, 1, 1, sizex, sizey, 0.0);
1307 img_output = cpl_table_new (1);
1309 for (region = 0 ; region < n_region; region ++){
1311 data_x = cpl_sprintf(
"DATA%d", region + 1);
1313 cpl_table_new_column_array (img_output, data_x, CPL_TYPE_DOUBLE, nwave);
1314 cpl_table_set_column_dimensions(img_output, data_x,
1316 const char * regname = cpl_table_get_string (detector,
"REGNAME", region);
1319 for (base = 0; base < nbase; base++){
1322 if (strstr(regname, baseString[base]) ||
1323 strstr(regname, baseString_bis[base]))
1328 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
1333 wavelength = cpl_array_new(nwave, CPL_TYPE_DOUBLE);
1334 cpl_vector *wavelength_vect = cpl_vector_new(nwave);
1339 pos = cpl_vector_new(2);
1340 for (wave = 0; wave < nwave; wave ++){
1343 cpl_vector_set(pos, 0, region + 1);
1344 cpl_vector_set(pos, 1, wave);
1346 result = cpl_polynomial_eval(fit2d, pos);
1348 result = cpl_vector_get (all_wavelength, region*nwave + wave) -
1349 cpl_vector_get (vect_index, wave) * step;
1350 cpl_array_set(wavelength, wave, result);
1351 cpl_vector_set (wavelength_vect, wave, result );
1354 for (ind = 0; ind < sizey; ind ++){
1356 if (cpl_image_get (img_profile, wave+1, ind+1, &nv) > 0.01){
1358 cpl_image_set (image_wave, wave+1, ind+1, result);
1360 cpl_image_set (image_real, wave+1, ind+1,
1362 cpl_vector_get (all_wavelength, region*nwave + wave));
1365 if (cpl_error_get_code()){
1367 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"The corner and "
1376 cpl_vector_delete(pos);
1382 cpl_matrix * matrix = cpl_matrix_new (1, nwave);
1383 const cpl_size deg_2=2;
1385 for (ind = 0; ind < nwave; ind++) {
1386 cpl_matrix_set(matrix, 0, ind, ind);
1389 fit_slope = cpl_polynomial_new(1);
1390 cpl_polynomial_fit(fit_slope, matrix, NULL, wavelength_vect, NULL,
1391 CPL_FALSE, °, °_2);
1393 pos=cpl_vector_new(1);
1394 for (wave = 0; wave < nwave; wave ++){
1395 cpl_vector_set(pos, 0, wave);
1396 result = cpl_polynomial_eval(fit_slope, pos)-
1397 cpl_vector_get (vect_index, wave) * step;
1398 cpl_array_set(wavelength, wave, result);
1400 cpl_vector_delete(pos);
1401 cpl_polynomial_delete(fit_slope);
1405 minwave = cpl_array_get_min(wavelength);
1406 maxwave = cpl_array_get_max(wavelength);
1410 if (minwave < cpl_array_get_min(wavelength))
1411 minwave = cpl_array_get_min(wavelength);
1414 if (maxwave > cpl_array_get_max(wavelength))
1415 maxwave = cpl_array_get_max(wavelength);
1419 cpl_table_set_array(img_output, data_x, 0, wavelength);
1421 cpl_array_delete(wavelength);
1425 cpl_vector_delete (all_wavelength);
1429 gravi_data_append_header (wave_map,
plist);
1431 cpl_propertylist * img_plist;
1433 for (ext = 0; ext < nb_ext; ext++ ){
1446 strcmp (plist_name,
"TEST_WAVE") &&
1451 gravi_data_add (wave_map, img_plist,
1455 else if (type_ext == 3)
1466 cpl_propertylist_append_string (
plist,
"EXTNAME",
1468 gravi_data_add (wave_map,
plist, cooef_table);
1469 cpl_propertylist_delete (
plist);
1473 cpl_polynomial_delete(fit2d);
1474 cpl_propertylist_append_double (primary_hdr, QC_MINWAVE_SC, minwave);
1475 cpl_propertylist_append_double (primary_hdr, QC_MAXWAVE_SC, maxwave);
1477 cpl_msg_info (cpl_func,
"wave corrected : QC_MINWAVE_SC = %e QC_MAXWAVE_SC = %e",
1482 imglist_wave = cpl_imagelist_new ();
1483 cpl_imagelist_set(imglist_wave,image_wave , 0);
1484 cpl_imagelist_set(imglist_wave, cpl_image_duplicate (img_profile), 1);
1485 cpl_imagelist_set(imglist_wave, image_real, 2);
1486 gravi_data_set_cube (wave_map,
"TEST_WAVE", imglist_wave);
1488 cpl_array_delete (dimension);
1494 cpl_frameset * allframes,
1495 const char * filename,
1496 const cpl_parameterlist * parlist,
1497 cpl_frameset * usedframes,
1499 const char * recipe,
1500 cpl_propertylist * applist){
1501 cpl_frameset * frameset;
1504 if ((filename == NULL) || (self == NULL)){
1505 cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
1506 "one of the inputs at least is NULL");
1507 return CPL_ERROR_NULL_INPUT;
1512 frameset = cpl_frameset_duplicate(usedframes);
1515 if (cpl_dfs_save_propertylist (allframes, self->primary_hdr, parlist,
1516 frameset, frame, recipe, applist,
1517 NULL, PACKAGE_STRING, filename ) != CPL_ERROR_NONE){
1518 cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1519 "Cannot save the first extension primary header");
1520 return CPL_ERROR_NULL_INPUT;
1524 for (ext = 0; ext < self->nb_ext; ext ++){
1525 if (self->exts_tbs[ext] != NULL)
1527 filename, CPL_IO_EXTEND);
1528 else if (self->exts_imgl[ext] != NULL)
1529 cpl_imagelist_save (self->exts_imgl[ext], filename,
1530 cpl_image_get_type (cpl_imagelist_get (self->exts_imgl[ext], 0)),
1531 self->exts_hdrs[ext], CPL_IO_EXTEND);
1533 cpl_frameset_delete (frameset);
1535 return CPL_ERROR_NONE;
1551 for (
int type_data = 0; type_data < 2; type_data ++) {
1555 for (
int pol= 0 ; pol < npol ; pol++ ) {
1560 cpl_array ** flux = cpl_table_get_data_array (oi_flux,
"FLUX");
1561 cpl_array ** fluxErr = cpl_table_get_data_array (oi_flux,
"FLUXERR");
1562 cpl_size nrow = cpl_table_get_nrow (oi_flux);
1566 for (cpl_size row = 0; row < nrow; row++) {
1567 double flux_mean = cpl_array_get_mean (flux[row]);
1568 cpl_array_divide_scalar (flux[row], flux_mean);
1569 cpl_array_divide_scalar (fluxErr[row], flux_mean);
1577 return CPL_ERROR_NONE;
1584 cpl_ensure (img, CPL_ERROR_NULL_INPUT, NULL);
1586 cpl_vector * vector;
1592 type_img = cpl_image_get_type (img);
1594 _image = cpl_image_cast (img, CPL_TYPE_DOUBLE);
1596 x = cpl_image_get_size_x (img);
1597 y = cpl_image_get_size_y (img);
1598 data = cpl_image_get_data_double(_image);
1599 vector = cpl_vector_new(x*y);
1600 for (
int i = 0 ; i < x*y; i++)
1601 cpl_vector_set(vector, i, data[i]);
1621cpl_error_code
gravi_dtps(
double xi,
double eta,
double raz,
double decz,
double * ra,
double * dec)
1623 double sdecz = sin(decz);
1624 double cdecz = cos(decz);
1625 double denom = cdecz - eta * sdecz;
1627 *dec = atan2 (sdecz+eta*cdecz, sqrt(xi*xi + denom*denom));
1628 *ra = atan2 (xi,denom) + raz;
1631 *ra = fmod (*ra, CPL_MATH_2PI);
1632 if ( *ra < 0.0 ) *ra += CPL_MATH_2PI;
1634 return CPL_ERROR_NONE;
1640 size_t rows=m->size1;
1641 size_t cols=m->size2;
1648 maxlen=gsl_vector_alloc(cols);
1649 for (col=0;col<cols;++col) {
1651 for (row=0;row<rows;++row) {
1652 buff=gsl_matrix_complex_get(m,row,col);
1653 sprintf(buf,
"%g + i%g", GSL_REAL (buff), GSL_IMAG(buff));
1657 gsl_vector_set(maxlen,col,ml);
1660 for (row=0;row<rows;++row) {
1661 for (col=0;col<cols;++col) {
1662 buff=gsl_matrix_complex_get(m,row,col);
1663 sprintf(buf,
"%g + i%g", GSL_REAL (buff), GSL_IMAG(buff));
1664 fprintf(stream,
"%s",buf);
1665 fill=gsl_vector_get(maxlen,col)+1-strlen(buf);
1667 fprintf(stream,
" ");
1669 fprintf(stream,
"\n");
1671 gsl_vector_free(maxlen);
1693 cpl_ensure_code (flat, CPL_ERROR_NULL_INPUT);
1694 cpl_ensure_code (dark, CPL_ERROR_NULL_INPUT);
1699 cpl_image * median_flat = cpl_imagelist_get(
1703 cpl_image * grad = cpl_image_duplicate(median_flat);
1704 int x, size_x = cpl_image_get_size_x (median_flat);
1705 int y, size_y = cpl_image_get_size_y (median_flat);
1708 cpl_vector * vect_mean = cpl_vector_new_from_image_row (median_flat, 1);
1709 cpl_vector * vector;
1710 for (y = 2; y <= size_y; y++) {
1711 cpl_vector_add (vect_mean, cpl_vector_new_from_image_row (median_flat, y));
1713 cpl_vector_divide_scalar (vect_mean, size_y);
1715 vector = cpl_vector_filter_median_create(vect_mean, 2);
1718 vector = cpl_vector_filter_median_create (vect_mean, 5);
1720 threshold = cpl_vector_get_max(vector)/100.;
1725 threshold = 20 * cpl_propertylist_get_double (p_dark,
QC_DARKRMS_SC);
1732 cpl_image_threshold(grad, threshold, threshold, 1., 0.);
1733 cpl_image * mask = cpl_image_duplicate(grad);
1736 cpl_imagelist * list_mask = cpl_imagelist_new();
1737 cpl_propertylist *
plist = cpl_propertylist_duplicate(
1739 cpl_propertylist_update_string(
plist,
"EXTNAME",
"FLAT_MASK");
1740 cpl_imagelist_set(list_mask, grad, 0);
1746 int region, nregion = cpl_table_get_ncol(profiles);
1748 cpl_array ** array_data;
1753 printf(
"%g \n", cpl_image_get(mask, 1, 1, NULL));
1756 for (region = 1; region <= nregion; region++) {
1757 regname = cpl_sprintf(
"DATA%d", region);
1758 printf(
"region %d \n", region);
1759 array_data=cpl_table_get_data_array(profiles, regname);
1761 for (x = 0; x < size_x; x++) {
1764 for (y = 0; y < size_y; y++) {
1765 printf(
"%d %g ", y, cpl_image_get(grad, x+1, y+1, NULL));
1766 if (cpl_image_get(grad, x+1, y+1, NULL) > 0.1){
1767 cpl_array_set(array_data[0], x+size_x*y, 0);
1771 sum+=cpl_array_get(array_data[0], x+size_x*y, NULL);
1774 for (y = 0; y < size_y; y++) {
1775 cpl_array_set(array_data[0], x+size_x*y,
1776 cpl_array_get(array_data[0], x+size_x*y, NULL)/sum);
1781 cpl_msg_info(cpl_func,
"Number of flat bad pixels : %lld", count);
1783 cpl_vector_delete(vect_mean);
1784 return(CPL_ERROR_NONE);
1808 fp = fopen(filename,
"w");
1814"* Mira batch generated by gravi_mira recipe \n"
1816"include, \"mira.i\";\n"
1817"dataset = mira_new(\"%s\");\n"
1818"mira_config, dataset, dim=100, pixelsize=0.4*MIRA_MILLIARCSECOND, xform=\"exact\";\n"
1819"rgl = rgl_new(\"smoothness\");\n"
1820"dim = mira_get_dim(dataset);\n"
1821"img0 = array(double, dim, dim);\n"
1822"img0(dim/2, dim/2) = 1.0;\n"
1823"img1 = mira_solve(dataset, img0, maxeval=500, verb=0, xmin=0.0, normalization=1,\n"
1824" regul=rgl, mu=1e6);\n"
1825"fh = fits_create(\"%s\", overwrite=1, bitpix=-64, dimlist=dimsof(img0)); \n"
1826"fits_write_header, fh; \n"
1827"fits_write_array, fh, img1;\n"
1831"quit" , input_file, output_file);
1843 char line[LINE_SIZE];
1844 fread(line, LINE_SIZE, 1, pFile);
1845 *mjd = atof(line+7);
1846 *pmx = atof(line+18);
1847 *pmy = atof(line+37);
1848 *dut = atof(line+58);
1855 double mjd, pmx, pmy, dut;
1856 fseek(pFile, 0, SEEK_SET);
1864 double mjd, pmx, pmy, dut;
1865 fseek(pFile, -LINE_SIZE, SEEK_END);
1867 while( flag != type)
1869 fseek(pFile, -2*LINE_SIZE, SEEK_CUR);
1872 fseek(pFile, 0, SEEK_SET);
1881 cpl_size last_mjd, n_entries;
1882 double *mjd, *pmx, *pmy, *dut;
1886 cpl_ensure (eop_file, CPL_ERROR_NULL_INPUT, NULL);
1889 pFile = fopen ((
char *)eop_file,
"r");
1893 cpl_msg_info (cpl_func,
"Load the file: %s", eop_file);
1899 n_entries = mjd_P - mjd_S;
1900 cpl_msg_info(cpl_func,
"Reading %lli earth orientation parameters.", n_entries);
1901 cpl_msg_info(cpl_func,
" First entry: MJD=%.1f", mjd_S);
1902 cpl_msg_info(cpl_func,
" Last IERS entry: MJD=%.1f", mjd_I);
1903 cpl_msg_info(cpl_func,
" Last predicted entry: MJD=%.1f", mjd_P);
1906 cpl_table * eop_table = cpl_table_new (n_entries);
1913 cpl_table_new_column (eop_table,
"FLAG", CPL_TYPE_STRING);
1914 cpl_table_fill_column_window_string (eop_table,
"FLAG", 0, n_entries,
" ");
1916 mjd = cpl_table_get_data_double (eop_table,
"MJD");
1917 pmx = cpl_table_get_data_double (eop_table,
"PMX");
1918 pmy = cpl_table_get_data_double (eop_table,
"PMY");
1919 dut = cpl_table_get_data_double (eop_table,
"DUT");
1920 flag = cpl_table_get_data_string (eop_table,
"FLAG");
1923 for(
int i=0; i<n_entries; i++)
1933 gravi_data_add (eop_data, NULL, eop_table);
1936 cpl_propertylist *
header = cpl_propertylist_new();
1937 cpl_propertylist_append_double (
header,
"ESO QC EOP_PARAM MJD_S", mjd_S);
1938 cpl_propertylist_append_double (
header,
"ESO QC EOP_PARAM MJD_I", mjd_I);
1939 cpl_propertylist_append_double (
header,
"ESO QC EOP_PARAM MJD_P", mjd_P);
1940 cpl_propertylist_append_double (
header,
"MJD-OBS", mjd_I);
1941 cpl_propertylist_append_string (
header,
"ESO PRO CATG",
"EOP_PARAM");
1942 cpl_propertylist_append_string (
header,
"ESO PRO TECH",
"CATALOG");
1943 cpl_propertylist_append_string (
header,
"ESO PRO TYPE",
"IERS");
1944 gravi_data_append_header (eop_data,
header);
1948 cpl_msg_warning (cpl_func,
"Cannot load the file: %s", eop_file);
1959cpl_image *
flat_profiled = cpl_image_extract (profile_mean, xmin, ymin, xmax, ymax);
1971 cpl_msg_debug (cpl_func,
"Spectra has >50 pixels -> flat high frequencies");
1972 cpl_image * specFlat = cpl_image_duplicate (
specMean);
1973 cpl_mask * kernel = cpl_mask_new (11, 1);
1976 cpl_mask_not (kernel);
1977 cpl_image_filter_mask (specFlat,
specMean, kernel, CPL_FILTER_MEDIAN,CPL_BORDER_FILTER);
1978 cpl_image_divide (
specMean, specFlat);
1980 cpl_mask_delete (kernel);
1984 cpl_image_fill_window (
specMean, 1, 1, nxc, 1, 1.0);
2019 cpl_ensure (spectrum_data, CPL_ERROR_NULL_INPUT, NULL);
2021 cpl_propertylist *
plist = cpl_propertylist_new ();
2026 gravi_data_append_header (output, cpl_propertylist_duplicate (
header));
2029 for (
int type_data = 0; type_data < 2; type_data ++ ) {
2031 for (
int pol = 0; pol < npol; pol ++) {
2037 cpl_size nwave = cpl_table_get_column_depth (spectrum_table,
"DATA1");
2038 cpl_size nrow = cpl_table_get_nrow (spectrum_table);
2043 cpl_table * vis_table = cpl_table_new (nbase*nrow);
2048 float complex** mVis = cpl_malloc (nbase*nrow *
sizeof(
float complex*));
2049 for (cpl_size row = 0; row < nbase*nrow; row ++)
2050 mVis[row] = cpl_malloc (nwave *
sizeof(
float complex));
2053 cpl_vector * vectX = cpl_vector_new (nrow);
2054 cpl_vector * vectY = cpl_vector_new (nrow);
2057 cpl_array ** tVis = cpl_table_get_data_array (vis_table,
"VISDATA");
2058 double * datX = cpl_vector_get_data (vectX);
2059 double * datY = cpl_vector_get_data (vectY);
2062 for (
int base = 0; base < nbase; base++) {
2063 cpl_msg_info_overwritable (cpl_func,
"Ellipse to type=%s, pol=%i over %i, base=%i",
2067 for (cpl_size row = 0; row < nrow; row ++) {
2068 cpl_size irow = row*nbase + base;
2069 cpl_table_set (vis_table,
"TIME", irow,
2070 cpl_table_get (spectrum_table,
"TIME", row, NULL));
2081 cpl_ensure (regA>=0 && regA>=0 && regA>=0 && regA>=0,
2082 CPL_ERROR_ILLEGAL_INPUT, NULL);
2093 for (cpl_size wave = 0 ; wave < nwave ; wave++) {
2097 for (cpl_size row = 0; row < nrow; row ++) {
2098 datX[row] = datC[row][wave] - datA[row][wave];
2099 datY[row] = datD[row][wave] - datB[row][wave];
2103 cpl_vector_subtract_scalar (vectY, cpl_vector_get_mean (vectY));
2104 cpl_vector_subtract_scalar (vectX, cpl_vector_get_mean (vectX));
2107 cpl_vector * phase = gravi_vectors_phase_create (vectX, vectY);
2108 cpl_vector_multiply_scalar (phase, phi_sign);
2111 for (cpl_size row = 0; row < nrow; row ++) {
2112 cpl_size irow = row*nbase + base;
2113 mVis[irow][wave] = (
float complex)
2114 (sqrt (datX[row]*datX[row] + datY[row]*datY[row]) *
2115 cexp (1.*I * cpl_vector_get (phase, row)));
2118 FREE (cpl_vector_delete, phase);
2122 for (cpl_size row = 0; row < nrow*nbase; row ++)
2123 tVis[row] = cpl_array_wrap_float_complex (mVis[row], nwave);
2126 FREE (cpl_free, datA);
2127 FREE (cpl_free, datB);
2128 FREE (cpl_free, datD);
2129 FREE (cpl_free, datD);
2134 FREE (cpl_vector_delete, vectX);
2135 FREE (cpl_vector_delete, vectY);
2138 cpl_propertylist_append_string (
plist,
"EXTNAME",
"ELLIPSE_VIS");
2139 cpl_propertylist_append_string (
plist,
"INSNAME",
GRAVI_INSNAME(type_data,pol,npol));
2140 cpl_propertylist_append_int (
plist,
"EXTVER",
GRAVI_EXTVER(type_data,pol,npol));
2142 gravi_data_add (output,
plist, vis_table);
2154 cpl_errorstate prestate = cpl_errorstate_get();
2155 double value = cpl_propertylist_get_double(
plist,
"ESO INS MLC WAVELENG");
2156 cpl_ensure (cpl_errorstate_is_equal(prestate), cpl_error_get_code(), 0.0);
2173 const cpl_parameterlist * parlist)
2175 cpl_table * detector_table, * spectrum_table;
2176 cpl_size row, n_row, reg, n_region;
2177 cpl_array * output = NULL;
2181 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
2182 cpl_ensure_code (parlist, CPL_ERROR_NULL_INPUT);
2185 int nsmooth = cpl_parameter_get_int (cpl_parameterlist_find_const (parlist,
"gravi.nsmooth_sc"));
2191 if ( !(strcmp(resolution,
"HIGH")) ) {
2192 cpl_msg_info(cpl_func,
"Default smoothing is 15 (HIGH)");
2195 else if ( !(strcmp(resolution,
"MEDIUM")) ) {
2196 cpl_msg_info(cpl_func,
"Default smoothing is 3 (MEDIUM)");
2199 else if ( !(strcmp(resolution,
"LOW")) ) {
2200 cpl_msg_info(cpl_func,
"Default is no smoothing of data (LOW)");
2203 cpl_msg_warning(cpl_func,
"Unknown spectral resolution thus no smoothing of data");
2209 if ( nsmooth <= 0 ) {
2210 cpl_msg_info (cpl_func,
"End function (no smoothing)");
2211 return CPL_ERROR_NONE;
2216 n_region = cpl_table_get_nrow (detector_table);
2220 n_row = cpl_table_get_nrow (spectrum_table);
2225 for (reg = 0; reg < n_region; reg++) {
2228 cpl_msg_info_overwritable(cpl_func,
"Smooth region %lld over %lld of SC", reg+1, n_region);
2229 cpl_array** arrays = cpl_table_get_data_array (spectrum_table,
GRAVI_DATA[reg]);
2232 for (row = 0; row < n_row; row++) {
2236 cpl_array_delete (arrays[row]);
2237 arrays[row] = output;
2245 cpl_propertylist_append_int (hdr_data,
"ESO QC P2VM NSMOOTH SC", nsmooth);
2246 cpl_propertylist_set_comment (hdr_data,
"ESO QC P2VM NSMOOTH SC",
"nb of smoothed channels in P2VM computation");
2250 return CPL_ERROR_NONE;
2255 cpl_table * phase_sc,
2256 cpl_table * phase_ft,
2259 int ind_sc, nrow, row, nbase = 6, base;
2260 double exptime, exptime_sc, opl, time_sc, time_ft, time_metrology;
2261 int nv, comp, nrow_met, nrow_sc;
2262 int tel_1[6] = {0,0,0,1,1,2};
2263 int tel_2[6] = {1,2,3,2,3,3};
2264 const cpl_array * time_array_ft, * time_array_sc;
2267 cpl_ensure (opl_table, CPL_ERROR_NULL_INPUT, NULL);
2268 cpl_ensure (phase_sc, CPL_ERROR_NULL_INPUT, NULL);
2269 cpl_ensure (phase_ft, CPL_ERROR_NULL_INPUT, NULL);
2272 time_array_ft = cpl_table_get_array (phase_ft,
"TIME", 0);
2273 time_array_sc = cpl_table_get_array (phase_sc,
"TIME", 0);
2274 nrow = cpl_array_get_size (time_array_ft);
2275 nrow_sc = cpl_array_get_size (time_array_sc);
2276 nrow_met = cpl_table_get_nrow (opl_table);
2281 gsl_matrix * A_data = gsl_matrix_calloc (nbase * nrow, 8), * A;
2283 gsl_vector * bis_data = gsl_vector_alloc (nbase * nrow), * bis;
2284 gsl_matrix * X = gsl_matrix_alloc (8, 8),
2285 * V = gsl_matrix_alloc (8, 8);
2286 gsl_vector * S = gsl_vector_alloc (8);
2287 gsl_vector * work = gsl_vector_alloc (8), * x = gsl_vector_alloc (8);
2291 exptime = cpl_array_get_int (time_array_ft, 1, &nv) -
2292 cpl_array_get_int (time_array_ft, 0, &nv);
2293 exptime_sc = cpl_array_get_int (time_array_sc, 1, &nv) -
2294 cpl_array_get_int (time_array_sc, 0, &nv);
2302 for (base = 0; base < nbase; base ++){
2305 const cpl_array * ft_array = cpl_table_get_array (phase_ft,
"PHASE", base);
2306 const cpl_array * sc_array = cpl_table_get_array (phase_sc,
"PHASE", base);
2307 char * opl1 = cpl_sprintf(
"OPL%d", tel_1[base]+1);
2308 char * opl2 = cpl_sprintf(
"OPL%d", tel_2[base]+1);
2311 cpl_array * temp = cpl_array_wrap_double (
2312 cpl_table_get_data_double (opl_table, opl1), nrow_met);
2313 cpl_array * opl_met1 = cpl_array_duplicate (temp);
2314 cpl_array_unwrap (temp);
2315 cpl_array * opl_met2 = cpl_array_wrap_double (
2316 cpl_table_get_data_double (opl_table, opl2), nrow_met);
2317 cpl_array_subtract (opl_met1, opl_met2);
2323 for (row = 0; row < nrow; row ++){
2325 gsl_matrix_set (A_data, base * nrow + row, 6,
2326 - cpl_array_get_double (ft_array, row, &nv));
2329 time_ft = cpl_array_get_int (time_array_ft, row, &nv);
2330 if (ind_sc < cpl_array_get_size (sc_array)){
2331 time_sc = cpl_array_get_int (time_array_sc, ind_sc, &nv);
2336 while(time_ft > (time_sc+exptime_sc/2.)){
2338 if (ind_sc < cpl_array_get_size (sc_array))
2339 time_sc = cpl_array_get_int (time_array_sc, ind_sc, &nv);
2348 if(ind_sc < nrow_sc) {
2349 phi_sc=cpl_array_get_double (sc_array, ind_sc, &nv);
2352 phi_sc=cpl_array_get_double (sc_array, nrow_sc - 1, &nv);
2356 phi_sc = cpl_array_get_double (sc_array, 0, &nv);
2360 gsl_matrix_set (A_data, base * nrow + row, 7, phi_sc);
2361 gsl_matrix_set (A_data, base * nrow + row, base, 1.0);
2369 time_metrology = cpl_table_get_int (opl_table,
"TIME", im, &nv);
2371 while ((time_metrology < (time_ft + exptime))){
2373 if (im < nrow_met) {
2374 opl += cpl_array_get_double (opl_met1, im, &nv);
2379 if (im < nrow_met) {
2380 time_metrology = cpl_table_get_int (opl_table,
"TIME", im, &nv);
2391 gsl_vector_set (bis_data, base * nrow + row, opl/comp);
2397 opl = (cpl_array_get_double (opl_met1, im, &nv) -
2398 cpl_array_get_double (opl_met1, im - 1, &nv)) * (time_ft -
2399 cpl_table_get_int (opl_table,
"TIME", im - 1, &nv))
2401 cpl_table_get_int (opl_table,
"TIME", im - 1, &nv)) +
2402 cpl_array_get_double (opl_met1, im - 1, &nv);
2404 gsl_vector_set (bis_data, base * nrow + row, opl);
2407 gsl_vector_set (bis_data, base * nrow + row,
2408 cpl_array_get_double (opl_met1, nrow_met - 1, &nv));
2412 gsl_vector_set (bis_data, base * nrow + row,
2413 cpl_array_get_double (opl_met1, 0, &nv));
2419 cpl_array_delete (opl_met1);
2420 cpl_array_unwrap (opl_met2);
2429 long n_row_A=nrow_sc*(int)(dit_sc/exptime+1);
2430 cpl_vector *i_A_vector = cpl_vector_new(n_row_A);
2433 int t0_sc=cpl_array_get_int (time_array_sc, 0, &nv);
2434 int tend_sc=cpl_array_get_int (time_array_sc, nrow_sc-1, &nv);
2437 for (row=0; row<nrow; row++){
2438 time_ft = cpl_array_get_int (time_array_ft, row, &nv);
2439 if ((time_ft >= t0_sc-dit_sc/2) && (time_ft < tend_sc+dit_sc/2)){
2440 time_mod=((int)(time_ft-(t0_sc-dit_sc/2)) % (
int)exptime_sc);
2441 if ( time_mod >= 0 && time_mod < dit_sc ) {
2442 cpl_vector_set (i_A_vector, i_A, row);
2450 A = gsl_matrix_alloc (nbase * n_row_A, 8);
2451 bis = gsl_vector_alloc (nbase * n_row_A);
2452 cpl_vector *time_A = cpl_vector_new(n_row_A);
2455 for (base = 0; base < nbase; base ++)
2456 for (i_A = 0; i_A < n_row_A; i_A++){
2457 row = cpl_vector_get(i_A_vector, i_A);
2458 for (col = 0; col < 8; col ++)
2459 gsl_matrix_set (A, base * n_row_A + i_A, col, gsl_matrix_get (A_data, base * nrow + row, col));
2461 gsl_vector_set (bis, base * n_row_A + i_A, gsl_vector_get (bis_data, base * nrow + row));
2463 cpl_vector_set (time_A, i_A, cpl_array_get_int (time_array_ft, row, &nv));
2466 cpl_vector_delete(i_A_vector);
2472 U = gsl_matrix_alloc (nbase * nrow, 8);
2473 gsl_matrix_memcpy (U, A);
2476 gsl_linalg_SV_decomp (U, V, S, work);
2477 gsl_linalg_SV_solve (U, V, S, bis, x);
2478 cpl_vector * opd_coeff = cpl_vector_new (2);
2479 cpl_vector_set (opd_coeff, 0, gsl_vector_get (x, 7));
2480 cpl_vector_set (opd_coeff, 1, gsl_vector_get (x, 6));
2482 cpl_msg_debug(cpl_func,
"Wavelength base %d => SC = %g, FT = %g\n",
2483 base, -cpl_vector_get(opd_coeff,0)*2*M_PI, cpl_vector_get(opd_coeff,1)*2*M_PI);
2486 if (PLOT_MET_PHASE_FIT)
2490 cpl_errorstate prestate = cpl_errorstate_get();
2491 gsl_matrix_memcpy (U, A);
2493 const cpl_vector ** vectors=malloc(3 *
sizeof(cpl_vector*));
2495 cpl_vector *vect_phase_sc_ft=cpl_vector_new(nrow*nbase);
2496 cpl_vector *vect_dopd_met=cpl_vector_new(nrow*nbase);
2497 cpl_vector *vect_diff=cpl_vector_new(nrow*nbase);
2498 for (row = 0; row < nrow*nbase; row ++){
2499 cpl_vector_set(vect_dopd_met, row, gsl_vector_get (bis, row));
2500 cpl_vector_set(vect_phase_sc_ft, row, gsl_matrix_get (A, row, 0)*gsl_vector_get (x, 0)+
2501 gsl_matrix_get (A, row, 1)*gsl_vector_get (x, 1)+
2502 gsl_matrix_get (A, row, 2)*gsl_vector_get (x, 2)+
2503 gsl_matrix_get (A, row, 3)*gsl_vector_get (x, 3)+
2504 gsl_matrix_get (A, row, 4)*gsl_vector_get (x, 4)+
2505 gsl_matrix_get (A, row, 5)*gsl_vector_get (x, 5)+
2506 gsl_matrix_get (A, row, 6)*gsl_vector_get (x, 6)+
2507 gsl_matrix_get (A, row, 7)*gsl_vector_get (x, 7));
2508 cpl_vector_set(vect_diff, row, cpl_vector_get(vect_dopd_met, row)-cpl_vector_get(vect_phase_sc_ft, row));
2511 vectors[1]=vect_phase_sc_ft;
2512 vectors[2]=vect_dopd_met;
2514 cpl_plot_vectors (cpl_sprintf(
"set title 'Met fit case %d a=%g b=%g'; set xlabel 'time[10-6s]'; set ylabel 'Phase_ft+Phase_sc, dopd_met';", base+1, gsl_vector_get (x, 0), gsl_vector_get (x, 1)),
2515 "",
"", vectors, 3);
2516 cpl_plot_vector(cpl_sprintf(
"set title 'Met fit case %d a=%g b=%g'; set xlabel 'time[10-6s]'; set ylabel 'Phase_ft+Phase_sc-dopd_met';", base+1, gsl_vector_get (x, 0), gsl_vector_get (x, 1)),
2518 cpl_vector_delete(vect_phase_sc_ft);
2519 cpl_vector_delete(vect_dopd_met);
2520 cpl_vector_delete(vect_diff);
2522 cpl_errorstate_set (prestate);
2525 gsl_matrix_free (A);
2526 gsl_matrix_free (A_data);
2527 gsl_matrix_free (U);
2528 gsl_matrix_free (V);
2529 gsl_vector_free (x);
2530 gsl_vector_free (bis);
2531 gsl_vector_free (bis_data);
2532 cpl_vector_delete(time_A);
2533 gsl_matrix_free (X);
2534 gsl_vector_free (S);
2535 gsl_vector_free (work);
2563 cpl_table * opl_table,
2567 cpl_ensure (metrology_table, CPL_ERROR_NULL_INPUT, NULL);
2568 cpl_ensure (opl_table, CPL_ERROR_NULL_INPUT, NULL);
2570 cpl_table * p2vm_met;
2573 cpl_vector * vectA, * vectB,
2574 * phase, * y_sigma, * init_val;
2576 cpl_array * temp, * coherence_fit, * phase_fit;
2577 const cpl_array * volt0;
2578 cpl_matrix * opd_matrix;
2579 int tel, infos = 0, n_tel;
2581 int val_to_fit2[] = {1,1,1,0}, nv;
2582 double mse, red_chisq;
2590 nb_row = cpl_table_get_nrow (opl_table);
2591 for (tel = 0; tel < 4; tel ++){
2592 opl = cpl_sprintf(
"OPL%d", tel + 1);
2593 cpl_table_new_column (opl_table, opl, CPL_TYPE_DOUBLE);
2598 volt0 = cpl_table_get_array (metrology_table,
"VOLT", 0);
2601 n_tel = cpl_array_get_size (volt0);
2606 int start_tel = n_tel/2 - 8;
2607 p2vm_met = cpl_table_new (n_tel / 2 - start_tel);
2608 cpl_table_new_column_array (p2vm_met,
"TRANSMISSION", CPL_TYPE_DOUBLE, 2);
2609 cpl_table_new_column_array (p2vm_met,
"COHERENCE", CPL_TYPE_DOUBLE, 2);
2610 cpl_table_new_column_array (p2vm_met,
"PHASE", CPL_TYPE_DOUBLE, 2);
2613 cpl_table_new_column (opl_table,
"TIME", CPL_TYPE_INT);
2615 if (cpl_error_get_code()){
2617 printf(
"error %f %s and %s \n", 1.0, cpl_error_get_message(), cpl_error_get_where());
2622 for (tel = n_tel/2 - 8; tel < n_tel/2; tel++){
2624 vectA = cpl_vector_new (nb_row);
2625 vectB = cpl_vector_new (nb_row);
2630 for (row = 0; row < nb_row; row ++){
2631 temp = cpl_array_duplicate (cpl_table_get_array (metrology_table,
2633 volt = cpl_array_cast (temp, CPL_TYPE_DOUBLE);
2634 cpl_array_delete (temp);
2635 cpl_vector_set (vectA, row, cpl_array_get_double (volt, 2*tel, &nv));
2636 cpl_vector_set (vectB, row, cpl_array_get_double (volt, 2*tel + 1, &nv));
2638 cpl_array_delete (volt);
2644 phase = gravi_vectors_phase_create (vectA, vectB);
2646 if (PLOT_MET_ELLIPSE)
2648 if (POSTSCRIPT_PLOT) ps_string=cpl_sprintf(
"set term png; set output 'plot_met_ellipse_T%d.png';", tel);
2649 else ps_string=cpl_sprintf(
" ");
2650 plot = cpl_bivector_wrap_vectors (vectA, vectB);
2651 cpl_plot_bivector (cpl_sprintf(
"set title 'Met ellipse Tel %d'; set xlabel 'C-A'; set ylabel 'D-B';", tel+1),
2654 if (POSTSCRIPT_PLOT) ps_string=cpl_sprintf(
"set term png; set output 'plot_met_phase_T%d.png';", tel);
2655 else ps_string=cpl_sprintf(
" ");
2656 cpl_plot_vector (cpl_sprintf(
"set title 'Met phase Tel %d'; set xlabel 'index'; set ylabel 'Phase';", tel+1),
2659 cpl_free(ps_string);
2663 if (cpl_error_get_code()){
2664 printf(
"error %f %s and %s \n", 4.0, cpl_error_get_message(), cpl_error_get_where());
2670 opd_matrix = cpl_matrix_new(nb_row, 1);
2672 for (i = 0; i < nb_row; i++){
2674 cpl_matrix_set(opd_matrix, i, 0,
2675 cpl_vector_get(phase, i) *
LAMBDA_MET/(2*M_PI));
2676 if (tel >= n_tel/2 - 8){
2678 if (tel < n_tel/2 - 4){
2679 opl = cpl_sprintf(
"OPL%d", tel - (n_tel/2 - 8) + 1);
2680 cpl_table_set_double (opl_table, opl, i,
2681 cpl_vector_get (phase, i) *
LAMBDA_MET/(2*M_PI));
2685 opl = cpl_sprintf(
"OPL%d", tel - (n_tel/2 - 4) + 1);
2686 double opl_ft = cpl_table_get_double (opl_table, opl, i, &nv);
2687 cpl_table_set_double (opl_table, opl, i, (cpl_vector_get (phase, i) *
LAMBDA_MET/(2*M_PI))- opl_ft);
2691 if (tel == n_tel/2 - 4)
2692 cpl_table_set_int (opl_table,
"TIME", i,
2693 cpl_table_get_int (metrology_table,
"TIME",
2696 if (cpl_error_get_code()){
2697 printf(
"error %f %s and %s \n", 5.0, cpl_error_get_message(), cpl_error_get_where());
2703 cpl_vector_delete(phase);
2709 vect = cpl_malloc(2*
sizeof(cpl_vector*));
2712 phase_fit = cpl_array_new(2, CPL_TYPE_DOUBLE);
2713 coherence_fit = cpl_array_new(2, CPL_TYPE_DOUBLE);
2714 trans = cpl_array_new(2, CPL_TYPE_DOUBLE);
2716 for (i = 0; i < 2; i++){
2722 y_sigma = cpl_vector_new(nb_row);
2723 cpl_vector_fill(y_sigma, 1);
2728 init_val = cpl_vector_new(4);
2729 cpl_vector_set(init_val, 0, 1);
2730 cpl_vector_set(init_val, 1, 1);
2731 cpl_vector_set(init_val, 2, 1);
2734 cpl_errorstate prestate = cpl_errorstate_get();
2735 cpl_fit_lvmq(opd_matrix, NULL, vect[i],
2737 &
dfda_sin, CPL_FIT_LVMQ_TOLERANCE, CPL_FIT_LVMQ_COUNT,
2738 CPL_FIT_LVMQ_MAXITER, &mse, &red_chisq, NULL);
2740 if (cpl_error_get_code()){
2741 printf(
"error %f %s and %s \n", 6.0, cpl_error_get_message(), cpl_error_get_where());
2745 if (!strcmp(
"The iterative process did not converge",
2746 cpl_error_get_message())){
2749 "did not converge");
2750 cpl_errorstate_set (prestate);
2754 "%g chi2 %g", tel, mse, red_chisq);
2759 cpl_array_set_double (coherence_fit, i,
2760 sqrt( pow( cpl_vector_get(init_val, 2), 2) +
2761 pow( cpl_vector_get(init_val, 1), 2)));
2763 cpl_array_set_double (phase_fit, i, atan2( cpl_vector_get(init_val, 2),
2764 cpl_vector_get(init_val, 1)));
2766 cpl_array_set_double (trans, i, cpl_vector_get(init_val, 0));
2768 if (cpl_error_get_code()){
2769 printf(
"error %f %s and %s \n", 7.0, cpl_error_get_message(), cpl_error_get_where());
2773 cpl_vector_delete(init_val);
2774 cpl_vector_delete(y_sigma);
2775 cpl_vector_delete (vect[i]);
2779 cpl_matrix_delete(opd_matrix);
2781 cpl_table_set_array (p2vm_met,
"COHERENCE", tel - start_tel, coherence_fit);
2782 cpl_array_subtract_scalar (phase_fit,
2783 cpl_array_get_double (phase_fit, 0, &nv));
2784 cpl_table_set_array (p2vm_met,
"PHASE", tel - start_tel, phase_fit);
2785 cpl_table_set_array (p2vm_met,
"TRANSMISSION", tel - start_tel, trans);
2787 cpl_array_delete (trans);
2788 cpl_array_delete (coherence_fit);
2789 cpl_array_delete (phase_fit);
2817 cpl_table * visMet_data, * fddl_data, * spectrum_sc;
2818 cpl_propertylist * primary_hdr;
2819 int nbrow_met, row, nbrow_sc;
2821 cpl_table * fddl_met_mean;
2824 cpl_ensure_code (oi_vis, CPL_ERROR_NULL_INPUT);
2825 cpl_ensure_code (p2vmred_data, CPL_ERROR_NULL_INPUT);
2826 cpl_ensure_code (preproc_data, CPL_ERROR_NULL_INPUT);
2827 cpl_ensure_code (thread>=0, CPL_ERROR_ILLEGAL_INPUT);
2834 fddl_met_mean = cpl_table_new (1);
2835 cpl_table_new_column_array (fddl_met_mean,
"FT_POS", CPL_TYPE_DOUBLE, 4);
2836 cpl_table_new_column_array (fddl_met_mean,
"SC_POS", CPL_TYPE_DOUBLE, 4);
2837 cpl_table_new_column_array (fddl_met_mean,
"PHASE_FC", CPL_TYPE_DOUBLE, 4);
2838 cpl_table_new_column (fddl_met_mean,
"TIME", CPL_TYPE_INT);
2849 nbrow_met = cpl_table_get_nrow (visMet_data);
2850 nbrow_sc = cpl_table_get_nrow (spectrum_sc);
2854 int * time = cpl_table_get_data_int (visMet_data,
"TIME");
2855 int exptime_sc = cpl_table_get_int (spectrum_sc,
"TIME", 1, &nv) -
2856 cpl_table_get_int (spectrum_sc,
"TIME", 0, &nv);
2857 cpl_array ** met_arrays = cpl_table_get_data_array (visMet_data,
"PHASE_FC");
2858 cpl_array * met_mean = cpl_array_new (4, CPL_TYPE_DOUBLE);
2859 cpl_array_fill_window (met_mean, 0, 4, 0.0);
2867 for (row = 0; row < nbrow_met; row ++){
2869 if ((time[row] > cpl_table_get_int (spectrum_sc,
"TIME", 0, &nv) - exptime_sc/2) &&
2870 (time[row] < cpl_table_get_int (spectrum_sc,
"TIME", nbrow_sc-1, &nv) + exptime_sc/2)){
2871 cpl_array_add (met_mean, met_arrays[row]);
2878 cpl_array_divide_scalar (met_mean, comp);
2884 cpl_table_set_array (fddl_met_mean,
"PHASE_FC", 0, met_mean);
2885 cpl_table_set_int (fddl_met_mean,
"TIME", 0,
2886 cpl_table_get_int (spectrum_sc,
"TIME", 0, &nv) );
2887 cpl_array_delete (met_mean);
2889 int nbrow_fddl = cpl_table_get_nrow (fddl_data);
2895 cpl_array ** fddl_ft = cpl_table_get_data_array (fddl_data,
"FT_POS");
2896 cpl_array ** fddl_sc = cpl_table_get_data_array (fddl_data,
"SC_POS");
2897 time = cpl_table_get_data_int (fddl_data,
"TIME");
2898 cpl_array * ft_pos = cpl_array_new (4, CPL_TYPE_DOUBLE);
2899 cpl_array * sc_pos = cpl_array_new (4, CPL_TYPE_DOUBLE);
2900 cpl_array_fill_window (ft_pos, 0, 4, 0.0);
2901 cpl_array_fill_window (sc_pos, 0, 4, 0.0);
2904 for (row = 0; row < nbrow_fddl; row ++){
2906 if ((time[row] > cpl_table_get_int (spectrum_sc,
"TIME", 0, &nv) - exptime_sc/2) &&
2907 (time[row] < cpl_table_get_int (spectrum_sc,
"TIME", nbrow_sc-1, &nv) + exptime_sc/2)){
2908 cpl_array_add (ft_pos, fddl_ft[row]);
2909 cpl_array_add (sc_pos, fddl_sc[row]);
2913 CPLCHECK_MSG (
"Problem during the compute of the mean of the fddl");
2917 cpl_array_divide_scalar (ft_pos, comp);
2918 cpl_array_divide_scalar (sc_pos, comp);
2924 cpl_table_set_array (fddl_met_mean,
"FT_POS", 0, ft_pos);
2925 cpl_table_set_array (fddl_met_mean,
"SC_POS", 0, sc_pos);
2926 cpl_array_delete (ft_pos);
2927 cpl_array_delete (sc_pos);
2930 cpl_propertylist * plist_img = cpl_propertylist_duplicate (
2932 cpl_propertylist_set_string (plist_img,
"EXTNAME",
"FDDL_MET_MEAN");
2933 gravi_data_add (oi_vis, plist_img, fddl_met_mean);
2934 cpl_propertylist_delete (plist_img);
2939 cpl_table_delete (fddl_met_mean);
2942 return CPL_ERROR_NONE;
2966 cpl_ensure_code (p2vm_map, CPL_ERROR_NULL_INPUT);
2967 cpl_ensure_code (preproc_data, CPL_ERROR_NULL_INPUT);
2971 cpl_ensure_code (spectrum_table, CPL_ERROR_ILLEGAL_INPUT);
2974 cpl_size nrow = cpl_table_get_nrow (spectrum_table);
2978 cpl_table * output_table = cpl_table_extract (spectrum_table, 0, 1);
2981 for (cpl_size reg = 0; reg < nreg ; reg++) {
2982 cpl_array ** arrays = cpl_table_get_data_array (spectrum_table,
GRAVI_DATA[reg]);
2983 cpl_array * array = cpl_table_get_data_array (output_table,
GRAVI_DATA[reg])[0];
2984 cpl_ensure_code (arrays, CPL_ERROR_ILLEGAL_INPUT);
2985 for (cpl_size row = 1; row < nrow ; row++) cpl_array_add (array, arrays[row]);
2993 return CPL_ERROR_NONE;
3007 int ntel = 4, nbase = 6, npol = 2;
3009 gsl_matrix * U, * V;
3010 gsl_vector * S, * work;
3013 cpl_ensure (vis_data, CPL_ERROR_NULL_INPUT, NULL);
3020 double M_tab[24]={ 1., -1., 0.0, 0.0,
3026 gsl_matrix * M_matrix=gsl_matrix_alloc(6,4);
3027 memcpy(gsl_matrix_ptr(M_matrix, 0, 0), M_tab, 24*
sizeof(
double));
3030 gsl_matrix * M_matrix2=gsl_matrix_alloc(6,8);
3031 gsl_vector * M_vector=gsl_vector_alloc(6);
3032 for (
int tel=0; tel<
ntel; tel++){
3033 gsl_matrix_get_col(M_vector, M_matrix, tel);
3034 gsl_matrix_set_col(M_matrix2, tel, M_vector);
3035 gsl_vector_scale(M_vector, -1.);
3036 gsl_matrix_set_col(M_matrix2, tel+
ntel, M_vector);
3038 gsl_vector_free(M_vector);
3041 file = fopen(
"M_matrix2.txt",
"w");
3048 U = gsl_matrix_alloc (8, 6);
3049 V = gsl_matrix_alloc (6, 6);
3050 S = gsl_vector_alloc (6);
3051 work = gsl_vector_alloc (6);
3053 gsl_matrix_transpose_memcpy(U, M_matrix2);
3054 gsl_linalg_SV_decomp (U, V, S, work);
3059 gsl_matrix * M_matrix2_inv = gsl_matrix_alloc(
ntel*2, nbase);
3060 for (
int j = 0; j <
ntel*2; j++) {
3061 for (
int i = 0; i < nbase; i++){
3063 for (
int ii = 0; ii < nbase; ii++){
3064 if( gsl_vector_get(S, ii) > 1e-14)
3065 wv_at += gsl_matrix_get(V, i, ii) / gsl_vector_get(S, ii) *
3066 gsl_matrix_get(U, j, ii);
3068 gsl_matrix_set(M_matrix2_inv, j, i, wv_at);
3072 gsl_matrix_free (V);
3073 gsl_matrix_free (U);
3074 gsl_vector_free (S);
3075 gsl_vector_free (work);
3080 file = fopen(
"M_matrix2_inv.txt",
"w");
3092 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT,
3093 "Missing OI_VIS (need split pol for SC and FT)");
3104 cpl_msg_info (cpl_func,
"*** 1 ) Compute the real FDDL position from their positions and Metrology ***");
3107 cpl_table * oi_flux;
3109 cpl_size nrow = cpl_table_get_nrow (oi_flux) / 4;
3114 gsl_matrix * fddl = gsl_matrix_alloc (nrow,
ntel*2);
3115 gsl_matrix * fddl2 = gsl_matrix_alloc (nrow,
ntel*2);
3117 for (cpl_size row=0; row<nrow; row++) {
3118 for (
int tel = 0; tel<
ntel; tel++) {
3120 value = cpl_table_get (oi_flux,
"SC_POS", row*
ntel + tel, NULL);
3121 gsl_matrix_set (fddl, row,tel,value);
3122 gsl_matrix_set (fddl2,row,tel,value*value);
3124 value = cpl_table_get (oi_flux,
"FT_POS", row*
ntel + tel, NULL);
3125 gsl_matrix_set (fddl, row,
ntel+tel,value);
3126 gsl_matrix_set (fddl2,row,
ntel+tel,value*value);
3131 gsl_matrix_scale (fddl, 1e-3);
3132 gsl_matrix_scale (fddl, 1e-6);
3135 file = fopen(
"FDDL_matrix.txt",
"w");
3143 gsl_matrix * met_data = gsl_matrix_alloc (nrow, 4);
3145 for (cpl_size row=0; row<nrow; row++) {
3146 for (
int tel = 0; tel<
ntel; tel++) {
3147 double value = cpl_table_get (oi_flux,
"OPD_MET_FC", row*
ntel + tel, NULL);
3148 gsl_matrix_set (met_data,row,tel,value);
3153 gsl_matrix_scale (met_data, 1e6);
3156 file = fopen(
"MET_data.txt",
"w");
3163 gsl_matrix * MET = gsl_matrix_alloc(nrow, nbase);
3164 gsl_blas_dgemm (CblasNoTrans, CblasTrans, 1., met_data, M_matrix, 0, MET);
3167 file = fopen(
"MET.txt",
"w");
3173 cpl_msg_info(cpl_func,
"Compute the FDDL linearity factors");
3175 gsl_matrix * model = gsl_matrix_calloc( nrow*nbase, Nmodel);
3176 for (cpl_size row=0; row<nrow; row++){
3177 for (
int base=0; base<nbase; base++){
3178 gsl_matrix_set(model, row*nbase+base, base, 1);
3179 for (
int tel=0; tel<
ntel*2; tel++) {
3180 gsl_matrix_set(model, row*nbase+base, nbase+tel,
3181 gsl_matrix_get(fddl, row, tel) * gsl_matrix_get(M_matrix2, base, tel));
3182 gsl_matrix_set(model, row*nbase+base, nbase+8+tel,
3183 gsl_matrix_get(fddl2, row, tel) * gsl_matrix_get(M_matrix2, base, tel));
3189 file = fopen(
"model.txt",
"w");
3195 U = gsl_matrix_alloc (nrow*nbase, Nmodel);
3196 V = gsl_matrix_alloc (Nmodel, Nmodel);
3197 S = gsl_vector_alloc (Nmodel);
3198 work = gsl_vector_alloc (Nmodel);
3199 gsl_matrix_memcpy(U, model);
3201 gsl_linalg_SV_decomp (U, V, S, work);
3203 gsl_vector * K_coeff = gsl_vector_alloc (Nmodel);
3204 gsl_vector * MET_vector = gsl_vector_alloc(nrow*nbase);
3205 memcpy (MET_vector->data, MET->data, nbase*nrow*
sizeof(
double));
3206 gsl_linalg_SV_solve (U, V, S, MET_vector, K_coeff);
3211 gsl_vector_free(work);
3212 gsl_vector_free(MET_vector);
3214 cpl_msg_info(cpl_func,
"Compute the real FDDL positions");
3215 gsl_matrix * FDDL_matrix=gsl_matrix_alloc(nrow, 8);
3216 for (cpl_size row=0; row<nrow; row++){
3217 for (
int tel=0; tel<8; tel++){
3218 gsl_matrix_set(FDDL_matrix, row, tel,
3219 gsl_vector_get(K_coeff, tel+6)*gsl_matrix_get(fddl, row, tel) +
3220 gsl_vector_get(K_coeff, tel+6+8)*gsl_matrix_get(fddl2, row, tel));
3225 for (cpl_size row=0; row<nrow; row++){
3226 for (
int base=0; base<nbase; base++){
3227 gsl_matrix_set(MET, row, base, gsl_matrix_get(MET, row, base)
3228 - gsl_matrix_get(model, row*nbase+base, base)
3229 * gsl_vector_get(K_coeff, base));
3239 gsl_matrix * FDDLdotM = gsl_matrix_alloc(nrow, nbase);
3240 gsl_matrix * METsub = gsl_matrix_alloc(nrow, nbase);
3241 gsl_matrix * FDDLcorrection = gsl_matrix_alloc(nrow,
ntel*2);
3243 memcpy (METsub->data, MET->data, nbase*nrow*
sizeof(
double));
3244 gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1., FDDL_matrix, M_matrix2, 0, FDDLdotM);
3245 gsl_matrix_sub(METsub, FDDLdotM);
3247 gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1., METsub, M_matrix2_inv, 0, FDDLcorrection);
3248 gsl_matrix_add(FDDL_matrix, FDDLcorrection);
3250 gsl_matrix_free(FDDLdotM);
3251 gsl_matrix_free(METsub);
3252 gsl_matrix_free(FDDLcorrection);
3256 file = fopen(
"MET.txt",
"w");
3259 file = fopen(
"coeff.txt",
"w");
3260 for (
int Imodel=0; Imodel<Nmodel;Imodel++) fprintf(file,
"%e \n", gsl_vector_get(K_coeff, Imodel));
3262 file = fopen(
"FDDL_matrix.txt",
"w");
3273 cpl_msg_info(cpl_func,
"*** 2 ) Compute the Phases ***");
3279 cpl_size nwave = cpl_table_get_nrow(oi_wavelength);
3280 cpl_array * wavenumber = cpl_array_new(nwave, CPL_TYPE_DOUBLE);
3283 for (cpl_size wave=0; wave<nwave; wave++)
3284 cpl_array_set(wavenumber, wave, (2.*M_PI/(((
double)cpl_table_get(oi_wavelength,
"EFF_WAVE", wave, NULL)*1.e6-0.021*1.908)/(1.-0.021))));
3286 file = fopen(
"wavenumber.txt",
"w");
3287 for (cpl_size i=0; i<nwave;i++) fprintf(file,
"%5.10g \n", cpl_array_get(wavenumber, i, NULL));
3294 cpl_array ** visdata_p1_orig = cpl_table_get_data_array(oi_vis,
"VISDATA");
3295 cpl_array ** visdata_p1 = cpl_malloc(cpl_table_get_nrow(oi_vis)*
sizeof(cpl_array *));
3298 cpl_array ** visdata_p2_orig = cpl_table_get_data_array(oi_vis,
"VISDATA");
3299 cpl_array ** visdata_p2 = cpl_malloc(cpl_table_get_nrow(oi_vis)*
sizeof(cpl_array *));
3302 file = fopen(
"vis_p1.txt",
"w");
3308 for (cpl_size row=0; row<nrow; row++){
3309 for (
int base=0; base < nbase; base++){
3310 visdata_p1[row*nbase+base]=cpl_array_duplicate(visdata_p1_orig[row*nbase+base]);
3313 for (cpl_size i=0; i<nwave;i++) fprintf(file,
"%f + i%f \t", creal(cpl_array_get_complex(visdata_p1[row*nbase+base], i, NULL)),
3314 cimag(cpl_array_get_complex(visdata_p1[row*nbase+base], i, NULL)));
3317 visdata_p2[row*nbase+base]=cpl_array_duplicate(visdata_p2_orig[row*nbase+base]);
3321 fprintf(file,
"\n");
3331 cpl_array * GD1 = cpl_array_new(nrow*nbase, CPL_TYPE_DOUBLE);
3332 cpl_array * GD2 = cpl_array_new(nrow*nbase, CPL_TYPE_DOUBLE);
3333 cpl_array * GD1_stat = cpl_array_new(nrow, CPL_TYPE_DOUBLE);
3334 cpl_array * GD2_stat = cpl_array_new(nrow, CPL_TYPE_DOUBLE);
3335 cpl_array * GD1_med = cpl_array_new(nbase, CPL_TYPE_DOUBLE);
3336 cpl_array * GD2_med = cpl_array_new(nbase, CPL_TYPE_DOUBLE);
3337 double std_gd1 = 0.;
3338 double std_gd2 = 0.;
3339 for (
int base=0; base < nbase; base++){
3340 for (cpl_size row=0; row<nrow; row++){
3341 double complex tmp = 0.0 * I + 0.0;
3342 for (cpl_size wave=1; wave<nwave; wave++)
3343 tmp += cpl_array_get_complex (visdata_p1[row*nbase+base], wave, NULL) * conj(cpl_array_get_complex (visdata_p1[row*nbase+base], wave-1, NULL));
3344 cpl_array_set(GD1 , row*nbase + base, carg(tmp));
3345 cpl_array_set(GD1_stat , row, carg(tmp));
3346 tmp = 0.0 * I + 0.0;
3347 for (cpl_size wave=1; wave<nwave; wave++)
3348 tmp += cpl_array_get_complex (visdata_p2[row*nbase+base], wave, NULL) * conj(cpl_array_get_complex (visdata_p2[row*nbase+base], wave-1, NULL));
3349 cpl_array_set(GD2 , row*nbase + base, carg(tmp));
3350 printf(
"%g ",carg(tmp));
3351 cpl_array_set(GD2_stat , row, carg(tmp));
3354 std_gd1+=cpl_array_get_stdev(GD1_stat)/nrow;
3355 std_gd2+=cpl_array_get_stdev(GD2_stat)/nrow;
3356 cpl_array_set(GD1_med, base, cpl_array_get_median(GD1_stat));
3357 cpl_array_set(GD2_med, base, cpl_array_get_median(GD2_stat));
3359 cpl_array_delete(GD1_stat);
3360 cpl_array_delete(GD2_stat);
3362 cpl_msg_info(cpl_func,
"GD rms average for pola 1 : %g[radians/element]", std_gd1);
3363 cpl_msg_info(cpl_func,
"GD rms average for pola 2 : %g[radians/element]", std_gd2);
3366 file = fopen(
"GD1.txt",
"w");
3367 for (cpl_size row=0; row<nrow; row++){
3368 for (
int base=0; base < nbase; base++){
3369 fprintf(file,
"%g \t", cpl_array_get(GD1 , row*nbase + base, NULL));
3371 fprintf(file,
"\n");
3374 file = fopen(
"GD2.txt",
"w");
3375 for (cpl_size row=0; row<nrow; row++){
3376 for (
int base=0; base < nbase; base++){
3377 fprintf(file,
"%g \t", cpl_array_get(GD1 , row*nbase + base, NULL));
3379 fprintf(file,
"\n");
3387 size_t * sort_met[6];
3388 for (
int base=0; base<nbase; base++){
3389 sort_met[base]=cpl_malloc(nrow*
sizeof(
size_t));
3390 gsl_sort_index (sort_met[base], gsl_matrix_ptr(MET, 0,base), nbase, nrow);
3394 double step = 0.000001;
3395 cpl_array * amp_sum=cpl_array_new(nspace, CPL_TYPE_DOUBLE_COMPLEX);
3396 cpl_array_fill_window_complex(amp_sum, 0, nspace, 0.0 * I + 0.0);
3397 cpl_array * amp=cpl_array_new(nspace, CPL_TYPE_DOUBLE_COMPLEX);
3398 gsl_matrix * A1_met = gsl_matrix_alloc (nbase, nwave);
3399 gsl_matrix * A2_met = gsl_matrix_alloc (nbase, nwave);
3400 cpl_array * i2step=cpl_array_new(nspace, CPL_TYPE_DOUBLE);
3402 CPLCHECK_NUL(
"Error before fitting the metrology slopes");
3403 for (
int i = 0; i < nspace; ++i) cpl_array_set(i2step, i, step*(
double)i*2.);
3407 for (
int base = 0; base < nbase; ++base) {
3408 for (cpl_size wave = 0; wave < nwave; ++wave) {
3410 amp_sum=cpl_array_new(nspace, CPL_TYPE_DOUBLE_COMPLEX);
3411 cpl_array_fill_window_complex(amp_sum, 0, nspace, 0.0 * I + 0.0);
3413 for (cpl_size row = 0; row < nrow; ++row) {
3414 cpl_array_fill_window_complex(amp, 0, nspace, (_Complex
double)cpl_array_get_float_complex(visdata_p1[sort_met[base][row]*nbase+base], wave, NULL));
3416 cpl_array_add(amp_sum, amp);
3419 cpl_array_abs(amp_sum);
3421 cpl_array_get_maxpos(amp_sum, &max_pos);
3422 gsl_matrix_set(A1_met, base, wave, max_pos*step);
3423 cpl_msg_info_overwritable(cpl_func,
"Fit phase sc for polar 1/2 of base %d/6 (wave %lld/%lld)", base+1, wave+1, nwave);
3424 CPLCHECK_NUL(
"Error when fitting the metrology slopes");
3429 for (
int base = 0; base < nbase; ++base) {
3430 for (cpl_size wave = 0; wave < nwave; ++wave) {
3432 amp_sum=cpl_array_new(nspace, CPL_TYPE_DOUBLE_COMPLEX);
3433 cpl_array_fill_window_complex(amp_sum, 0, nspace, 0.0 * I + 0.0);
3435 for (cpl_size row = 0; row < nrow; ++row) {
3436 cpl_array_fill_window_complex(amp, 0, nspace, (_Complex
double)cpl_array_get_float_complex(visdata_p2[sort_met[base][row]*nbase+base], wave, NULL));
3438 cpl_array_add(amp_sum, amp);
3441 cpl_array_abs(amp_sum);
3443 cpl_array_get_maxpos(amp_sum, &max_pos);
3444 gsl_matrix_set(A2_met, base, wave, max_pos*step);
3445 cpl_msg_info_overwritable(cpl_func,
"Fit phase sc for polar 2/2 of base %d/6 (wave %lld/%lld)", base+1, wave+1, nwave);
3446 CPLCHECK_NUL(
"Error when fitting the metrology slopes");
3450 cpl_array_delete(amp_sum);
3451 cpl_array_delete(amp);
3452 cpl_array_delete(i2step);
3456 file = fopen(
"A1_met.txt",
"w");
3459 file = fopen(
"A2_met.txt",
"w");
3470 cpl_msg_info(cpl_func,
"Reconstruct unwrap phase ...");
3471 cpl_array * SC1b_unwrap;
3472 cpl_array * SC2b_unwrap;
3473 cpl_array * slope = cpl_array_new(nwave, CPL_TYPE_DOUBLE_COMPLEX);
3474 for (
int base=0; base < nbase; base++){
3475 SC1b_unwrap = cpl_array_new (nwave, CPL_TYPE_DOUBLE_COMPLEX);
3476 cpl_array_fill_window_complex (SC1b_unwrap, 0, nwave, (
double complex)(0.0 + 0.0 * I));
3477 SC2b_unwrap = cpl_array_new (nwave, CPL_TYPE_DOUBLE_COMPLEX);
3478 cpl_array_fill_window_complex (SC2b_unwrap, 0, nwave, (
double complex)(0.0 + 0.0 * I));
3479 for (cpl_size row=0; row<nrow; row++){
3480 for (cpl_size wave=0; wave<nwave; wave++){
3481 cpl_array_set(slope, wave,cpl_array_get(visdata_p1[row*nbase+base], wave, NULL)*
3483 gsl_matrix_get(MET, row, base)
3484 *gsl_matrix_get(A1_met, base, wave)
3485 -wave*cpl_array_get(GD1_med, base, NULL))
3488 cpl_array_add(SC1b_unwrap, slope);
3489 for (cpl_size wave=0; wave<nwave; wave++){
3490 cpl_array_set(slope, wave,cpl_array_get(visdata_p2[row*nbase+base], wave, NULL)*
3492 gsl_matrix_get(MET, row, base)
3493 *gsl_matrix_get(A2_met, base, wave)
3494 -wave*cpl_array_get(GD2_med, base, NULL))
3497 cpl_array_add(SC2b_unwrap, slope);
3499 cpl_array_divide_scalar(SC1b_unwrap, nrow);
3500 cpl_array_divide_scalar(SC2b_unwrap, nrow);
3502 cpl_array_arg(SC1b_unwrap);
3503 cpl_array_arg(SC2b_unwrap);
3506 for (cpl_size row=0; row<nrow; row++){
3507 for (cpl_size wave=0; wave<nwave; wave++){
3508 cpl_array_set(slope, wave,cpl_array_get(visdata_p1[row*nbase+base], wave, NULL)*
3510 gsl_matrix_get(MET, row, base)
3511 *gsl_matrix_get(A1_met, base, wave)
3512 -wave*cpl_array_get(GD1_med, base, NULL))
3520 cpl_array_delete(SC1b_unwrap);
3521 cpl_array_delete(SC2b_unwrap);
3531 for (
int tel = 0; tel<4; tel++ ) {
3532 cpl_msg_info (cpl_func,
"FDDL linearity K FT%i = %f, K SC%i = %f ", tel+1, gsl_vector_get(K_coeff, tel+6),
3533 tel+1, gsl_vector_get(K_coeff, tel+4+6));
3534 qc_name=cpl_sprintf(
"ESO QC FDDL_LIN K_FT%i", tel+1);
3535 cpl_propertylist_append_double (disp_header, qc_name,gsl_vector_get(K_coeff, tel+6));
3536 cpl_propertylist_set_comment (disp_header, qc_name,
"[-] K fddl linearity factor");
3537 qc_name=cpl_sprintf(
"ESO QC FDDL_LIN K_SC%i", tel+1);
3538 cpl_propertylist_append_double (disp_header, qc_name, gsl_vector_get(K_coeff, tel+4+6));
3539 cpl_propertylist_set_comment (disp_header, qc_name,
"[-] K fddl linearity factor");
3542 for (
int tel = 0; tel<4; tel++ ) {
3543 cpl_msg_info (cpl_func,
"FDDL linearity K2 FT%i = %f, K2 SC%i = %f ", tel,
3544 gsl_vector_get (K_coeff, tel+6+8),
3545 tel, gsl_vector_get(K_coeff, tel+4+6));
3546 qc_name=cpl_sprintf(
"ESO QC FDDL_LIN K2_FT%i", tel+1);
3547 cpl_propertylist_append_double (disp_header, qc_name,gsl_vector_get(K_coeff, tel+6+8));
3548 cpl_propertylist_set_comment (disp_header, qc_name,
"[-] K2 fddl linearity factor");
3549 qc_name=cpl_sprintf(
"ESO QC FDDL_LIN K2_SC%i", tel+1);
3550 cpl_propertylist_append_double (disp_header, qc_name, gsl_vector_get(K_coeff, tel+4+6+8));
3551 cpl_propertylist_set_comment (disp_header, qc_name,
"[-] K2 fddl linearity factor");
3558 gsl_matrix_free(fddl);
3559 gsl_matrix_free(fddl2);
3560 gsl_matrix_free(met_data);
3561 gsl_matrix_free(M_matrix);
3562 gsl_matrix_free(M_matrix2);
3563 gsl_matrix_free(MET);
3564 gsl_matrix_free(model);
3565 gsl_vector_free(K_coeff);
3566 gsl_matrix_free(FDDL_matrix);
3567 cpl_array_delete(wavenumber);
3570 gsl_matrix_free(A1_met);
3571 gsl_matrix_free(A2_met);
3572 cpl_array_delete(GD1_med);
3573 cpl_array_delete(GD2_med);
3581 size_t rows=m->size1;
3582 size_t cols=m->size2;
3588 maxlen=gsl_vector_alloc(cols);
3589 for (col=0;col<cols;++col) {
3591 for (row=0;row<rows;++row) {
3592 sprintf(buf,fmt,gsl_matrix_get(m,row,col));
3596 gsl_vector_set(maxlen,col,ml);
3599 for (row=0;row<rows;++row) {
3600 for (col=0;col<cols;++col) {
3601 sprintf(buf,fmt,gsl_matrix_get(m,row,col));
3602 fprintf(stream,
"%s",buf);
3603 fill=gsl_vector_get(maxlen,col)+1-strlen(buf);
3605 fprintf(stream,
" ");
3607 fprintf(stream,
"\n");
3609 gsl_vector_free(maxlen);
3633 cpl_ensure (metrology_table, CPL_ERROR_NULL_INPUT, NULL);
3634 cpl_vector * vectA, * vectB, *opl_vect;
3635 const cpl_array * volt;
3642 cpl_size nb_row = cpl_table_get_nrow (metrology_table);
3646 cpl_table * opdmet_table = cpl_table_new (nb_row);
3647 cpl_table_new_column (opdmet_table,
"TIME", CPL_TYPE_INT);
3648 for (cpl_size row = 0; row < nb_row; row++){
3649 cpl_table_set_int (opdmet_table,
"TIME", row,
3650 cpl_table_get_int (metrology_table,
"TIME",
3651 row, NULL) + mjd_obs);
3655 for (
int gravi_type = 0; gravi_type < 2; gravi_type++ ){
3656 int comb = (gravi_type ==
GRAVI_SC ? 1 : 2);
3659 for (
int tel = 0; tel < nb_tel; tel++){
3662 vectA = cpl_vector_new (nb_row);
3663 vectB = cpl_vector_new (nb_row);
3665 for (cpl_size row = 0; row < nb_row; row ++){
3666 volt = cpl_table_get_array ( metrology_table,
"VOLT", row);
3667 cpl_vector_set (vectA, row, cpl_array_get (volt , n_diode - 2*(comb*nb_tel - tel), NULL));
3668 cpl_vector_set (vectB, row, cpl_array_get (volt , n_diode - 2*(comb*nb_tel - tel) + 1, NULL));
3672 opl_vect = gravi_vectors_phase_create (vectA, vectB);
3673 cpl_vector_multiply_scalar (opl_vect,
LAMBDA_MET/(2.0*M_PI));
3675 FREE (cpl_vector_delete, vectA);
3676 FREE (cpl_vector_delete, vectB);
3681 sprintf (name,
"OPL_FC_SC%d", tel + 1);
3682 cpl_table_wrap_double (opdmet_table, cpl_vector_get_data(opl_vect), name);
3683 cpl_table_set_column_unit (opdmet_table, name,
"m");
3687 sprintf (name,
"OPD_FC%d", tel + 1);
3688 sprintf (name2,
"OPL_FC_SC%d", tel + 1);
3689 cpl_table_duplicate_column (opdmet_table, name, opdmet_table, name2);
3690 cpl_table_set_column_unit (opdmet_table, name,
"m");
3695 sprintf (name,
"OPL_FC_FT%d", tel + 1);
3696 cpl_table_wrap_double (opdmet_table, cpl_vector_get_data(opl_vect), name);
3697 cpl_table_set_column_unit (opdmet_table, name,
"m");
3700 sprintf (name2,
"OPD_FC%d", tel + 1);
3701 cpl_table_subtract_columns (opdmet_table, name2, name);
3702 cpl_table_set_column_unit (opdmet_table, name,
"m");
3705 cpl_vector_unwrap (opl_vect);
3712 return opdmet_table;
3719 cpl_ensure_code (phase_table, CPL_ERROR_NULL_INPUT);
3721 cpl_table * input_table = cpl_table_duplicate (phase_table);
3722 cpl_array ** ref = cpl_table_get_data_array (input_table,
"PHASE");
3723 cpl_array ** out = cpl_table_get_data_array (phase_table,
"PHASE");
3725 for (
int base = 0; base < nbase; base++) {
3726 for (
int clo = 0; clo < 2; clo ++) {
3727 for (
int b = 0; b < 2; b ++) {
3730 cpl_array_multiply_scalar (tmp, sign);
3731 cpl_array_add (out[base], tmp);
3732 cpl_array_multiply_scalar (tmp, sign);
3736 cpl_array_divide_scalar (out[base], 3.0);
3738 FREE (cpl_table_delete, input_table);
3741 return CPL_ERROR_NONE;
3754 cpl_ensure (vis_met, CPL_ERROR_NULL_INPUT, NULL);
3759 cpl_size nrow = cpl_table_get_nrow (vis_met)/
ntel;
3764 cpl_table * opd_met = cpl_table_new (nrow);
3765 cpl_table_new_column (opd_met,
"TIME", CPL_TYPE_INT);
3766 cpl_table_set_column_unit (opd_met,
"TIME",
"us");
3770 p_opd_met = cpl_malloc(
ntel*
sizeof(
double*));
3771 for (
int tel=0; tel<
ntel; tel++) {
3772 sprintf (name,
"OPD_FC%d", tel + 1);
3773 cpl_table_new_column (opd_met, name, CPL_TYPE_DOUBLE);
3774 cpl_table_set_column_unit (opd_met, name,
"m");
3775 p_opd_met[tel]=cpl_table_get_data_double(opd_met, name);
3782 double * p_vis_met=cpl_table_get_data_double(vis_met,
"PHASE_FC");
3783 for (cpl_size row = 0; row < nrow; row++){
3786 cpl_table_set_int (opd_met,
"TIME", row,
3787 cpl_table_get_int (vis_met,
"TIME", row*
ntel, NULL));
3790 for (
int tel=0; tel<
ntel; tel++) {
3791 p_opd_met[tel][row] = p_vis_met[row*
ntel+tel]*
LAMBDA_MET/(2.0*M_PI);
3797 cpl_free(p_opd_met);
3805 if (cpl_table_get (phase_ft,
"PHASE_SC", row*nbase+base, NULL) !=0
3806 && (row % (nrow/5) == 0) ) {
3807 double phase_sc = cpl_table_get (phase_ft,
"PHASE_SC", row*nbase+base, NULL);
3808 double phasec_sc = gsl_matrix_get (A_data, base * nrow + row, 7);
3809 cpl_msg_info (
"TEST",
"FT base %i row %lld : phi_sc = %g phase_sc = %g diff = %g [rad]",
3810 base, row, phasec_sc, phase_sc, phasec_sc - phase_sc);
3811 double phase_met = cpl_table_get (phase_ft,
"PHASE_MET_FC", row*nbase+base, NULL);
3812 double phasec_met = gsl_vector_get (bis_data, base * nrow + row) /
LAMBDA_MET * CPL_MATH_2PI;
3813 cpl_msg_info (
"TEST",
"FT base %i row %lld : phi_met = %g phase_met = %g diff = %g [rad]",
3814 base, row, phasec_met, phase_met, phasec_met - phase_met);
3829 cpl_table * phase_sc,
3830 cpl_table * phase_ft,
3833 int nbase = 6,
ntel = 4;
3834 double opl, time_sc, time_ft, time_met;
3838 cpl_ensure (vis_met, CPL_ERROR_NULL_INPUT, NULL);
3839 cpl_ensure (phase_sc, CPL_ERROR_NULL_INPUT, NULL);
3840 cpl_ensure (phase_ft, CPL_ERROR_NULL_INPUT, NULL);
3843 cpl_size nrow = cpl_table_get_nrow (phase_ft) / nbase;
3844 cpl_size nrow_sc = cpl_table_get_nrow (phase_sc) / nbase;
3845 cpl_size nrow_met = cpl_table_get_nrow (vis_met) /
ntel;
3849 int * time_FT = cpl_table_get_data_int (phase_ft,
"TIME");
3850 int * time_SC = cpl_table_get_data_int (phase_sc,
"TIME");
3854 double exptime_ft = time_FT[nbase] - time_FT[0];
3855 double exptime_sc = time_SC[nbase] - time_SC[0];
3858 double * ft_phase = cpl_table_get_data_double (phase_ft,
"PHASE");
3859 double * sc_phase = cpl_table_get_data_double (phase_sc,
"PHASE");
3860 double * phase_met = cpl_table_get_data_double (vis_met,
"PHASE_FC");
3864 gsl_matrix * A_data = gsl_matrix_calloc (nbase * nrow, 8);
3865 gsl_matrix * U, * A;
3866 gsl_vector * bis_data = gsl_vector_alloc (nbase * nrow), * bis;
3867 gsl_matrix * X = gsl_matrix_alloc (8, 8);
3868 gsl_matrix * V = gsl_matrix_alloc (8, 8);
3869 gsl_vector * S = gsl_vector_alloc (8);
3870 gsl_vector * work = gsl_vector_alloc (8);
3871 gsl_vector * x = gsl_vector_alloc (8);
3878 for (
int base = 0; base < nbase; base ++) {
3888 for (cpl_size row = 0; row < nrow; row ++){
3890 gsl_matrix_set (A_data, base * nrow + row, 6, - ft_phase[row*nbase+base]);
3893 time_ft = time_FT[row*nbase+base];
3894 if (ind_sc < nrow_sc) time_sc = time_SC[ind_sc*nbase+base];
3898 while(time_ft > (time_sc+exptime_sc/2.)){
3900 if (ind_sc < nrow_sc) time_sc = time_SC[ind_sc*nbase+base];
3908 if(ind_sc < nrow_sc) phi_sc = sc_phase[ind_sc*nbase+base];
3909 else phi_sc = sc_phase[(nrow_sc - 1)*nbase+base];
3911 else phi_sc = sc_phase[0*nbase+base];
3915 gsl_matrix_set (A_data, base * nrow + row, 7, phi_sc);
3916 gsl_matrix_set (A_data, base * nrow + row, base, 1.0);
3923 time_met = cpl_table_get_int (vis_met,
"TIME", im*
ntel, &nv);
3925 while ((time_met < (time_ft + exptime_ft))){
3927 if (im < nrow_met) {
3928 opl += (phase_met[im*
ntel+tel0] - phase_met[im*
ntel+tel1]) *
LAMBDA_MET / CPL_MATH_2PI;
3933 if (im < nrow_met) {
3934 time_met = cpl_table_get_int (vis_met,
"TIME", im*
ntel, &nv);
3945 gsl_vector_set (bis_data, base * nrow + row, opl/comp);
3951 double opd1 = (phase_met[(im-1)*
ntel+tel0] - phase_met[(im-1)*
ntel+tel1]) *
LAMBDA_MET / CPL_MATH_2PI;
3952 double opd2 = (phase_met[im*
ntel+tel0] - phase_met[im*
ntel+tel1]) *
LAMBDA_MET / CPL_MATH_2PI;
3953 double opd = (opd2 - opd1) *
3954 (time_ft - cpl_table_get_int (vis_met,
"TIME", (im-1)*
ntel, &nv)) /
3955 (time_met - cpl_table_get_int (vis_met,
"TIME", (im-1)*
ntel, &nv)) +
3957 gsl_vector_set (bis_data, base * nrow + row, opd);
3960 double opd = (phase_met[(nrow_met-1)*
ntel+tel0] - phase_met[(nrow_met-1)*
ntel+tel1]) *
LAMBDA_MET / CPL_MATH_2PI;
3961 gsl_vector_set (bis_data, base * nrow + row, opd);
3965 double opd = (phase_met[0*
ntel+tel0] - phase_met[0*
ntel+tel1]) *
LAMBDA_MET / CPL_MATH_2PI;
3966 gsl_vector_set (bis_data, base * nrow + row, opd);
3978 long n_row_A=nrow_sc*(int)(dit_sc/exptime_ft+1);
3979 cpl_vector *i_A_vector = cpl_vector_new(n_row_A);
3982 int t0_sc = time_SC[0*nbase];
3983 int tend_sc = time_SC[(nrow_sc-1)*nbase];
3987 for (cpl_size row=0; row<nrow; row++){
3988 time_ft = time_FT[row*nbase];
3989 if ((time_ft >= t0_sc-dit_sc/2) && (time_ft < tend_sc+dit_sc/2)){
3990 time_mod=((int)(time_ft-(t0_sc-dit_sc/2)) % (
int)exptime_sc);
3991 if ( time_mod >= 0 && time_mod < dit_sc ) {
3992 cpl_vector_set (i_A_vector, i_A, row);
4000 A = gsl_matrix_alloc (nbase * n_row_A, 8);
4001 bis = gsl_vector_alloc (nbase * n_row_A);
4002 cpl_vector *time_A = cpl_vector_new(n_row_A);
4004 for (
int base = 0; base < nbase; base ++)
4005 for (cpl_size i_A = 0; i_A < n_row_A; i_A++){
4006 cpl_size row = cpl_vector_get(i_A_vector, i_A);
4007 for (
int col = 0; col < 8; col ++)
4008 gsl_matrix_set (A, base * n_row_A + i_A, col, gsl_matrix_get (A_data, base * nrow + row, col));
4010 gsl_vector_set (bis, base * n_row_A + i_A, gsl_vector_get (bis_data, base * nrow + row));
4012 cpl_vector_set (time_A, i_A, time_FT[row*nbase+base]);
4015 cpl_vector_delete(i_A_vector);
4021 U = gsl_matrix_alloc (nbase * nrow, 8);
4022 gsl_matrix_memcpy (U, A);
4025 gsl_linalg_SV_decomp (U, V, S, work);
4026 gsl_linalg_SV_solve (U, V, S, bis, x);
4027 cpl_vector * opd_coeff = cpl_vector_new (3);
4028 cpl_vector_set (opd_coeff, 0, gsl_vector_get (x, 7));
4029 cpl_vector_set (opd_coeff, 1, gsl_vector_get (x, 6));
4031 cpl_msg_debug (cpl_func,
"Wavelength => SC = %g, FT = %g\n",
4032 cpl_vector_get(opd_coeff,0)*2*M_PI, cpl_vector_get(opd_coeff,1)*2*M_PI);
4039 cpl_table * table_output = cpl_table_new (nrow * nbase);
4040 const char * table_name[9] = {
"A0",
"A1",
"A2",
"A3",
"A4",
"A5",
"A6",
"A7",
"B"};
4043 double ** table_value = cpl_malloc (9 *
sizeof(
double*));
4044 for (
int col = 0; col < 9; col++)
4045 table_value[col] = cpl_malloc (nrow * nbase *
sizeof(
double));
4049 for (
int base = 0; base < nbase; base ++)
4050 for (cpl_size row = 0; row < nrow; row++) {
4051 for (
int col = 0; col < 8; col ++)
4052 table_value[col][base * nrow + row] = gsl_matrix_get (A, base * nrow + row, col);
4054 table_value[8][base * nrow + row] = gsl_vector_get (bis, base * nrow + row);
4059 for (
int col = 0; col < 9; col++) {
4060 cpl_table_wrap_double (table_output, table_value[col], table_name[col]);
4064 cpl_propertylist * table_header = cpl_propertylist_new ();
4065 for (
int col = 0; col < 8; col ++)
4070 cpl_table_save (table_output, NULL, table_header,
"matrix_AB.fits", CPL_IO_CREATE);
4078 cpl_vector *vect_phase_sc_ft=cpl_vector_new(nrow*nbase);
4079 cpl_vector *vect_dopd_met=cpl_vector_new(nrow*nbase);
4080 cpl_vector *vect_diff=cpl_vector_new(nrow*nbase);
4081 for (cpl_size row = 0; row < nrow*nbase; row ++){
4082 cpl_vector_set(vect_dopd_met, row, gsl_vector_get (bis, row));
4083 cpl_vector_set(vect_phase_sc_ft, row,
4084 gsl_matrix_get (A, row, 0)*gsl_vector_get (x, 0)+
4085 gsl_matrix_get (A, row, 1)*gsl_vector_get (x, 1)+
4086 gsl_matrix_get (A, row, 2)*gsl_vector_get (x, 2)+
4087 gsl_matrix_get (A, row, 3)*gsl_vector_get (x, 3)+
4088 gsl_matrix_get (A, row, 4)*gsl_vector_get (x, 4)+
4089 gsl_matrix_get (A, row, 5)*gsl_vector_get (x, 5)+
4090 gsl_matrix_get (A, row, 6)*gsl_vector_get (x, 6)+
4091 gsl_matrix_get (A, row, 7)*gsl_vector_get (x, 7));
4092 cpl_vector_set(vect_diff, row, cpl_vector_get(vect_dopd_met, row)-cpl_vector_get(vect_phase_sc_ft, row));
4095 double rms_fit_phase_met = cpl_vector_get_stdev(vect_diff);
4096 cpl_msg_info (cpl_func,
"RMS of residuals on fit of a.phi_ft+b.phi_sc+c = met : %g", rms_fit_phase_met);
4097 cpl_vector_set (opd_coeff, 2, rms_fit_phase_met);
4099 cpl_msg_info (
"TEST",
"coeff SC = %.20g [um]", cpl_vector_get (opd_coeff, 0) * CPL_MATH_2PI * 1e6);
4100 cpl_msg_info (
"TEST",
"coeff FT = %.20g [um]", cpl_vector_get (opd_coeff, 1) * CPL_MATH_2PI * 1e6);
4101 cpl_msg_info (
"TEST",
"residual = %.20g [um]", rms_fit_phase_met * CPL_MATH_2PI * 1e6);
4106 if (rms_fit_phase_met > 1e-7 ){
4107 cpl_msg_info (cpl_func,
"*************************************************");
4108 cpl_msg_warning (cpl_func,
"**** !!! residuals of the fit too high !!! ****");
4109 cpl_msg_warning (cpl_func,
"**** SC and RMN may be desynchronized ****");
4110 cpl_msg_warning (cpl_func,
"**** (or out of the envelope in LOW) ****");
4111 cpl_msg_info (cpl_func,
"*************************************************");
4114 if (PLOT_MET_PHASE_FIT) {
4117 cpl_errorstate prestate = cpl_errorstate_get();
4118 const cpl_vector ** vectors=malloc(3 *
sizeof(cpl_vector*));
4120 vectors[1]=vect_phase_sc_ft;
4121 vectors[2]=vect_dopd_met;
4123 cpl_plot_vectors (cpl_sprintf(
"set title 'Met fit case a=%g b=%g'; set xlabel 'time[10-6s]'; set ylabel 'Phase_ft+Phase_sc, dopd_met';", gsl_vector_get (x, 0), gsl_vector_get (x, 1)),
4124 "",
"", vectors, 3);
4125 cpl_plot_vector(cpl_sprintf(
"set title 'Met fit case a=%g b=%g'; set xlabel 'time[10-6s]'; set ylabel 'Phase_ft+Phase_sc-dopd_met';", gsl_vector_get (x, 0), gsl_vector_get (x, 1)),
4128 cpl_errorstate_set (prestate);
4131 FREE(cpl_vector_delete, vect_phase_sc_ft);
4132 FREE(cpl_vector_delete, vect_dopd_met);
4133 FREE(cpl_vector_delete, vect_diff);
4134 gsl_matrix_free (A);
4135 gsl_matrix_free (A_data);
4136 gsl_matrix_free (U);
4137 gsl_matrix_free (V);
4138 gsl_vector_free (x);
4139 gsl_vector_free (bis);
4140 gsl_vector_free (bis_data);
4141 cpl_vector_delete(time_A);
4142 gsl_matrix_free (X);
4143 gsl_vector_free (S);
4144 gsl_vector_free (work);
4155 cpl_table * vis_MET,
4159 cpl_ensure (spectrumsc_table, CPL_ERROR_NULL_INPUT, NULL);
4160 cpl_ensure (vis_FT, CPL_ERROR_NULL_INPUT, NULL);
4161 cpl_ensure (vis_MET, CPL_ERROR_NULL_INPUT, NULL);
4162 cpl_ensure (dit_sc>0, CPL_ERROR_ILLEGAL_INPUT, NULL);
4164 cpl_size nbase = 6,
ntel = 4;
4165 cpl_size nrow_sc = cpl_table_get_nrow (spectrumsc_table);
4168 cpl_table * vis_SC = cpl_table_new (nrow_sc * nbase);
4172 for (cpl_size row_sc = 0; row_sc < nrow_sc; row_sc ++) {
4173 double value = cpl_table_get (spectrumsc_table,
"TIME", row_sc, NULL);
4174 for (cpl_size base = 0; base < nbase; base++)
4175 cpl_table_set (vis_SC,
"TIME", row_sc*nbase+base, value);
4185 int * first_met = cpl_table_get_data_int (vis_SC,
"FIRST_MET");
4186 int * last_met = cpl_table_get_data_int (vis_SC,
"LAST_MET");
4187 int * first_ft = cpl_table_get_data_int (vis_SC,
"FIRST_FT");
4188 int * last_ft = cpl_table_get_data_int (vis_SC,
"LAST_FT");
4193 double * phase_met = cpl_table_get_data_double (vis_MET,
"PHASE_FC");
4194 double * phase_ft = cpl_table_get_data_double (vis_FT,
"PHASE");
4200 double * opd_sc = cpl_table_get_data_double (vis_SC,
"OPD");
4203 for (cpl_size base = 0; base < nbase; base++) {
4204 for (cpl_size row_sc = 0; row_sc < nrow_sc; row_sc ++) {
4205 cpl_size nsc = row_sc * nbase + base;
4208 double opd_met = 0.0;
4209 for (cpl_size row_met = first_met[nsc] ; row_met < last_met[nsc]; row_met++) {
4212 opd_met += (phase_met[nmet0] - phase_met[nmet1]) *
LAMBDA_MET / CPL_MATH_2PI;
4214 cpl_size nframe_met = last_met[nsc] - first_met[nsc];
4215 if (nframe_met != 0 ) opd_met /= nframe_met;
4218 double opd_ft = 0.0;
4219 for (cpl_size row_ft = first_ft[nsc] ; row_ft < last_ft[nsc]; row_ft++) {
4220 cpl_size nft = row_ft * nbase + base;
4221 opd_ft += phase_ft[nft] * 2.2e-6 / CPL_MATH_2PI;
4223 cpl_size nframe_ft = last_ft[nsc] - first_ft[nsc];
4224 if (nframe_ft != 0 ) opd_ft /= nframe_ft;
4227 opd_sc[nsc] = opd_met + opd_ft;
4241 cpl_ensure_code (phase_table, CPL_ERROR_NULL_INPUT);
4243 int ntel = 4, nbase = 6;
4244 int tel_1[6] = {0,0,0,1,1,2};
4245 int tel_2[6] = {1,2,3,2,3,3};
4247 gsl_matrix * gsl_SC_kernel = NULL;
4248 gsl_vector * phase_coeff = NULL;
4249 gsl_matrix * M = NULL;
4250 gsl_matrix * U = NULL;
4251 gsl_matrix * V = NULL;
4252 gsl_vector * S = NULL;
4253 gsl_vector * work = NULL;
4254 cpl_matrix * M_inv = NULL;
4255 cpl_matrix * SC_kernel_mat_final = NULL;
4256 gsl_vector * Ks = NULL;
4257 cpl_matrix * kernel = NULL;
4266 M = gsl_matrix_alloc (nbase,
ntel);
4267 gsl_matrix_set_zero (M);
4269 for (
int j = 0; j < nbase; j++){
4270 gsl_matrix_set (M, j, tel_1[j], 1);
4271 gsl_matrix_set (M, j, tel_2[j], -1);
4280 U = gsl_matrix_alloc (6, 4);
4281 V = gsl_matrix_alloc (4, 4);
4282 S = gsl_vector_alloc (4);
4283 work = gsl_vector_alloc (4);
4285 gsl_matrix_memcpy (U, M);
4286 gsl_linalg_SV_decomp (U, V, S, work);
4292 double * a_inv_data = cpl_malloc(
ntel * nbase *
sizeof(
double));
4293 for (
int j = 0; j < nbase; j++) {
4294 for (
int i = 0; i <
ntel; i++){
4296 for (
int ii = 0; ii <
ntel; ii++){
4297 if( gsl_vector_get(S, ii) > 1e-14)
4298 wv_at += gsl_matrix_get(V, i, ii) / gsl_vector_get(S, ii) *
4299 gsl_matrix_get(U, j, ii);
4301 a_inv_data[j + i * nbase] = wv_at;
4305 gsl_matrix_free (V);
4306 gsl_matrix_free (U);
4307 gsl_vector_free (S);
4308 gsl_vector_free (work);
4310 M_inv = cpl_matrix_wrap (
ntel, nbase, a_inv_data);
4318 kernel = cpl_matrix_new (nbase, nbase);
4320 for (
int j = 0; j < nbase; j++) {
4321 for (
int k = 0; k < nbase; k++) {
4323 for (
int ii = 0; ii <
ntel; ii++){
4324 ai += gsl_matrix_get (M, j, ii)*cpl_matrix_get (M_inv, ii, k);
4327 cpl_matrix_set (kernel, j, k, ai - 1);
4329 cpl_matrix_set (kernel, j, k, ai);
4333 cpl_matrix_unwrap (M_inv);
4334 cpl_free (a_inv_data);
4343 int nrow = cpl_table_get_nrow (phase_table) / nbase;
4345 double * pphase = cpl_table_get_data_double (phase_table,
"PHASE");
4346 cpl_ensure_code (pphase, CPL_ERROR_ILLEGAL_INPUT);
4349 Ks = gsl_vector_alloc (nbase* nrow);
4350 for (
int k = 0; k < nbase; k++) {
4351 for (cpl_size row = 0;row < nrow; row++) {
4353 for (
int ii = 0; ii < nbase; ii++){
4354 ai += cpl_matrix_get (kernel, k, ii) * pphase[row*nbase+ii];
4356 gsl_vector_set (Ks, row + k * nrow, ai);
4367 cpl_array * phase_temp;
4369 double * SC_kernel = cpl_malloc ( nbase*nbase * nrow *
sizeof (
double));
4370 double * SC_kernel2 = cpl_malloc ( nbase*nbase * nrow *
sizeof (
double));
4371 cpl_array * ones = cpl_array_new (nrow, CPL_TYPE_DOUBLE);
4373 for (
int i = 0; i < nbase; i++) {
4374 for (
int k = 0; k < nbase; k ++){
4377 phase_temp = cpl_array_new (nrow, CPL_TYPE_DOUBLE);
4378 for (cpl_size row = 0; row < nrow; row++)
4379 cpl_array_set (phase_temp, row, pphase[row*nbase+i]);
4381 cpl_array_fill_window_double (ones, 0, nrow, 1);
4382 cpl_array_multiply_scalar (ones, cpl_matrix_get (kernel, i, k));
4383 cpl_array_multiply_scalar (phase_temp, cpl_matrix_get (kernel, i, k));
4384 ph_data = cpl_array_get_data_double (phase_temp);
4385 ones_t = cpl_array_get_data_double (ones);
4387 memcpy (SC_kernel2 + (i*nbase + k) * nrow , ph_data, nrow *
sizeof(
double));
4388 memcpy (SC_kernel + (i*nbase + k) * nrow, ones_t, nrow *
sizeof(
double));
4391 cpl_array_delete (phase_temp);
4396 FREE (cpl_array_delete, ones);
4399 cpl_matrix * temp = cpl_matrix_wrap (nbase, nbase* nrow, SC_kernel);
4400 cpl_matrix * SC_kernel_mat = cpl_matrix_duplicate (temp);
4401 cpl_matrix * SC_kernel_mat2 = cpl_matrix_wrap (nbase, nbase* nrow, SC_kernel2);
4403 cpl_matrix_append (SC_kernel_mat, SC_kernel_mat2, 1);
4405 SC_kernel_mat_final = cpl_matrix_extract (SC_kernel_mat, 0, 0, 1, 1, 11, nbase*nrow);
4407 cpl_matrix_unwrap (temp);
4408 cpl_matrix_unwrap (SC_kernel_mat2);
4409 cpl_free (SC_kernel2);
4410 cpl_free (SC_kernel);
4411 cpl_matrix_delete (SC_kernel_mat);
4413 gsl_SC_kernel = gsl_matrix_alloc (nbase*nrow, 11);
4415 for (
int j = 0; j < cpl_matrix_get_nrow(SC_kernel_mat_final); j++){
4416 for (
int k = 0; k < cpl_matrix_get_ncol(SC_kernel_mat_final); k++)
4417 gsl_matrix_set (gsl_SC_kernel, k, j, cpl_matrix_get (SC_kernel_mat_final, j, k));
4424 U = gsl_matrix_alloc (nbase*nrow, 11);
4425 V = gsl_matrix_alloc (11, 11);
4426 S = gsl_vector_alloc (11);
4427 phase_coeff = gsl_vector_alloc (11);
4428 work = gsl_vector_alloc (11);
4429 gsl_matrix_memcpy (U, gsl_SC_kernel);
4431 gsl_linalg_SV_decomp (U, V, S, work);
4432 for (
int i = 0; i < 11; i++)
4433 if (gsl_vector_get (S, i) < 1e-10)
4434 gsl_vector_set (S, i , 0);
4435 gsl_linalg_SV_solve (U, V, S, Ks, phase_coeff);
4441 for (
int base = 0; base < nbase - 1; base ++){
4442 double f = gsl_vector_get (phase_coeff, nbase + base);
4443 cpl_msg_info (cpl_func,
"correction factor = 1 %+.20f", f);
4444 for (cpl_size row = 0; row < nrow; row++) {
4445 pphase[row*nbase+base] *= 1 - f;
4454 FREE (gsl_matrix_free, M);
4455 FREE (gsl_vector_free, Ks);
4456 FREE (cpl_matrix_delete, SC_kernel_mat_final);
4457 FREE (cpl_matrix_delete, kernel);
4458 FREE (gsl_matrix_free, gsl_SC_kernel);
4459 FREE (gsl_matrix_free, U);
4460 FREE (gsl_matrix_free, V);
4461 FREE (gsl_vector_free, S);
4462 FREE (gsl_vector_free, phase_coeff);
4463 FREE (gsl_vector_free, work);
4466 return CPL_ERROR_NONE;
4473 double coh_len= lambda * lambda / delta_lambda / 3;
4478 value = exp (-1 * opd * opd / (coh_len*coh_len/2.) );
4486 if (wave == nwave/2 && base == 0 & pol == 0) {
4487 int step = nwave == 5 ? 100 : 1;
4489 cpl_vector ** array = cpl_malloc (3 *
sizeof(cpl_vector*));
4491 cpl_vector_multiply_scalar (array[0], 1e6);
4495 cpl_vector_subtract_scalar (tmp, cpl_vector_get_mean (tmp));
4497 cpl_vector_divide_scalar (array[1], cpl_vector_get_max (array[1]));
4498 cpl_vector_delete (tmp);
4502 cpl_plot_vectors (NULL, NULL, NULL, (
const cpl_vector **)array, 3);
4503 FREELOOP (cpl_vector_delete, array, 3);
4532 cpl_table * detector_table,
4533 cpl_table * opd_table)
4536 cpl_ensure (spectrum_table, CPL_ERROR_NULL_INPUT, NULL);
4537 cpl_ensure (detector_table, CPL_ERROR_NULL_INPUT, NULL);
4538 cpl_ensure (opd_table, CPL_ERROR_NULL_INPUT, NULL);
4544 cpl_table * wave_table = cpl_table_new (1);
4548 cpl_size nregion = cpl_table_get_nrow (detector_table);
4549 cpl_size nrow = cpl_table_get_nrow (spectrum_table);
4552 cpl_array * wave_array = cpl_array_new (nwave, CPL_TYPE_DOUBLE);
4558 for (
int reg = 0; reg < nregion; reg++) {
4559 cpl_msg_info (cpl_func,
"Compute wave region %i over %lli", reg+1, nregion);
4568 cpl_vector * opd_vector = cpl_vector_new (nrow);
4569 for (cpl_size row = 0; row < nrow; row ++ ) {
4570 double value = cpl_table_get (opd_table,
"OPD", row*nbase+base, NULL);
4571 cpl_vector_set (opd_vector, row, value);
4576 cpl_vector_get_min (opd_vector)*1e6,
4577 cpl_vector_get_max (opd_vector)*1e6);
4580 for (cpl_size wave = 0; wave < nwave; wave++) {
4582 cpl_vector * X_vector;
4584 cpl_vector_subtract_scalar (X_vector, cpl_vector_get_mean (X_vector));
4585 cpl_vector_divide_scalar (X_vector, 1.4 * cpl_vector_get_stdev (X_vector));
4589 double lbd0 = 1.97e-6 + (2.48e-6 - 1.97e-6) / nwave * wave;
4595 cpl_size nA = (nwave == 5 ? 20 : 100);
4596 double searchA = 0.05;
4597 cpl_vector * V_vector = cpl_vector_new (nA);
4598 cpl_vector * R_vector = cpl_vector_new (nrow);
4599 cpl_vector * I_vector = cpl_vector_new (nrow);
4601 for (cpl_size iA = 0; iA < nA; iA++) {
4602 double A = phi_sign * (1 - searchA + (2*searchA * iA) / nA ) * CPL_MATH_2PI / lbd0;
4604 for (cpl_size row = 0; row < nrow; row++) {
4605 cpl_vector_set (R_vector, row, cos (A * cpl_vector_get (opd_vector, row)) *
4606 cpl_vector_get (env_vector, row) );
4607 cpl_vector_set (I_vector, row, sin (A * cpl_vector_get (opd_vector, row)) *
4608 cpl_vector_get (env_vector, row));
4611 cpl_vector_multiply (R_vector, X_vector);
4612 cpl_vector_multiply (I_vector, X_vector);
4613 double Rvalue = cpl_vector_get_mean (R_vector);
4614 double Ivalue = cpl_vector_get_mean (I_vector);
4617 cpl_vector_set (V_vector, iA, Rvalue*Rvalue + Ivalue*Ivalue);
4622 if (!(reg%8) && (wave == 0 || wave == nwave-1)) {
4623 cpl_plot_vector (NULL, NULL, NULL, V_vector);
4629 cpl_array_set (wave_array, wave, lbd);
4631 FREE (cpl_vector_delete, env_vector);
4632 FREE (cpl_vector_delete, V_vector);
4633 FREE (cpl_vector_delete, R_vector);
4634 FREE (cpl_vector_delete, I_vector);
4635 FREE (cpl_vector_delete, X_vector);
4641 "m", CPL_TYPE_DOUBLE, nwave);
4642 cpl_table_set_array (wave_table,
GRAVI_DATA[reg], 0, wave_array);
4644 cpl_vector_delete (opd_vector);
4647 cpl_array_delete (wave_array);
4661 double * gd, cpl_size nrow)
4664 cpl_ensure_code (input, CPL_ERROR_NULL_INPUT);
4665 cpl_ensure_code (sigma, CPL_ERROR_NULL_INPUT);
4666 cpl_ensure_code (gd, CPL_ERROR_ILLEGAL_OUTPUT);
4668 cpl_size nsigma = cpl_array_get_size (sigma);
4669 double lbd = 1.0 / cpl_array_get (sigma,nsigma/2,NULL);
4672 double * sigdata = cpl_malloc (
sizeof(
double complex) * nsigma);
4673 for (cpl_size w=0; w<nsigma; w++) sigdata[w] = cpl_array_get (sigma, w, NULL);
4677 double coherence = 0.5 * nsigma / fabs (sigdata[0] - sigdata[nsigma-1]);
4678 double coherence_bb = 1 / fabs (sigdata[0] - sigdata[nsigma-1]);
4679 double width = CPL_MIN (size * coherence_bb, coherence);
4681 cpl_msg_info (
"TEST",
"coh = %g and %g [um]", coherence*1e6, coherence_bb*1e6);
4684 double complex ** waveform = cpl_calloc (10,
sizeof(
double complex*));
4685 double * step = cpl_calloc (10,
sizeof(
double));
4689 while (width > lbd/50) {
4690 step[nloop] = width / size;
4691 cpl_msg_info (cpl_func,
"Build waveform of %g [um] with step [%gum]",
4692 width *1e6, step[nloop] *1e6);
4694 waveform[nloop] = cpl_malloc (
sizeof(
double complex) * size * nsigma);
4695 for (cpl_size s=0; s<size; s++) {
4696 double x = (s-size/2) * step[nloop];
4697 for (cpl_size w=0; w<nsigma; w++)
4698 waveform[nloop][s*nsigma+w] = cexp (-2.*I*CPL_MATH_PI * x * sigdata[w]);
4706 cpl_msg_info (cpl_func,
"Loop on %lli rows to compute gdelay", nrow);
4709 double complex * visdata = cpl_malloc (
sizeof(
double complex) * nsigma);
4712 for (cpl_size row = 0; row<nrow; row++) {
4716 for (cpl_size w=0; w<nsigma; w++) visdata[w] = cpl_array_get_complex (input[row], w, NULL);
4719 for (
int loop = 0; loop < nloop; loop++) {
4720 double current_max = -1, current_gd = 0.0;
4723 for (cpl_size s=0; s<size; s++) {
4724 double complex tmp = 0.0 * I + 0.0;
4725 for (cpl_size w=0; w<nsigma; w++) {tmp += visdata[w] * waveform[loop][s*nsigma+w];}
4726 double P = cabs (tmp);
4727 if ( P > current_max) { current_max = P; current_gd = (s-size/2) * step[loop]; }
4731 for (cpl_size w=0; w<nsigma; w++) visdata[w] *= cexp (-2.*I*CPL_MATH_PI*current_gd*sigdata[w]);
4732 gd[row] += current_gd;
4740 FREE (cpl_free, visdata);
4741 FREE (cpl_free, sigdata);
4742 FREE (cpl_free, step);
4746 return CPL_ERROR_NONE;
4761 cpl_ensure (input, CPL_ERROR_NULL_INPUT, 0);
4762 cpl_ensure (sigma, CPL_ERROR_NULL_INPUT, 0);
4766 cpl_size nsigma = cpl_array_get_size (sigma);
4767 cpl_size ninput = cpl_array_get_size (input);
4769 cpl_ensure (nsigma == ninput, CPL_ERROR_ILLEGAL_INPUT, 0);
4773 width = 1.0 * nsigma / fabs (cpl_array_get (sigma,0,&nv) - cpl_array_get (sigma,nsigma-1,&nv));
4774 step = 1. / cpl_array_get (sigma,nsigma/2,&nv);
4778 double current_gd = -1e10;
4779 double current_max = -1.0;
4783 for (
double x = gd0-width/2.0 ; x < gd0+width/2.0 ; x += step) {
4784 double complex tmp = 0.0 * I + 0.0;
4785 for (cpl_size w=0; w<nsigma; w++)
4786 tmp += cpl_array_get_complex (input, w, &nv) * cexp (-2.*I*CPL_MATH_PI * x * cpl_array_get (sigma,w,&nv));
4787 if ( cabs (tmp) > current_max ) {
4788 current_max = cabs (tmp);
4796 step = step / 100.0;
4804 for (
double x = gd0-width/2 ; x < gd0+width/2 ; x += step) {
4805 double complex tmp = 0.0 * I + 0.0;
4806 for (cpl_size w=0; w<nsigma; w++)
4807 tmp += cpl_array_get_complex (input, w, &nv) * cexp (-2.*I*CPL_MATH_PI * x * cpl_array_get (sigma,w,&nv));
4808 if ( cabs (tmp) > current_max ) {
4809 current_max = cabs (tmp);
4828 cpl_ensure (input, CPL_ERROR_NULL_INPUT, 0);
4829 cpl_ensure (sigma, CPL_ERROR_NULL_INPUT, 0);
4833 cpl_size nsigma = cpl_array_get_size (sigma);
4834 cpl_size ninput = cpl_array_get_size (input);
4836 cpl_ensure (nsigma == ninput, CPL_ERROR_ILLEGAL_INPUT, 0);
4840 width = 1.0 * nsigma / fabs (cpl_array_get (sigma,0,&nv) - cpl_array_get (sigma,nsigma-1,&nv));
4841 step = 1. / cpl_array_get (sigma,nsigma/2,&nv);
4845 double current_gd = -1e10;
4846 double current_max = -1.0;
4850 for (
double x = gd0-width/2.0 ; x < gd0+width/2.0 ; x += step) {
4851 double complex tmp = 0.0 * I + 0.0;
4852 for (cpl_size w=0; w<nsigma; w++)
4853 tmp += cpl_array_get_complex (input, w, &nv) * cexp (-2.*I*CPL_MATH_PI * x * cpl_array_get (sigma,w,&nv));
4854 if ( cabs (tmp) > current_max ) {
4855 current_max = cabs (tmp);
4872 cpl_ensure (input, CPL_ERROR_NULL_INPUT, 0);
4873 cpl_ensure (wavenumber, CPL_ERROR_NULL_INPUT, 0);
4875 double complex interspectra = 0.0 + I * 0.0;
4876 double sum_wavenumber_diff = 0.0;
4878 cpl_size size = cpl_array_get_size (input);
4879 cpl_size sizew = cpl_array_get_size (wavenumber);
4881 cpl_ensure (size == sizew, CPL_ERROR_ILLEGAL_INPUT, 0);
4883 for (cpl_size n = 1; n < size; n++) {
4886 interspectra += cpl_array_get_complex (input, n, NULL) *
4887 conj (cpl_array_get_complex (input, n - 1, NULL));
4890 sum_wavenumber_diff += cpl_array_get (wavenumber, n, NULL) - cpl_array_get (wavenumber, n-1, NULL);
4894 return carg ( interspectra ) / sum_wavenumber_diff * (size-1) / (2*M_PI);
4938 cpl_ensure_code (bivector_in, CPL_ERROR_NULL_INPUT);
4940 cpl_bivector_sort(bivector_in, bivector_in, CPL_SORT_ASCENDING, CPL_SORT_BY_Y);
4942 int size = cpl_bivector_get_size(bivector_in);
4943 int sizeout = size*(0.5);
4944 int start = (size-sizeout)/2;
4945 cpl_matrix * coord = cpl_matrix_new(1,sizeout);
4946 cpl_vector * vector = cpl_vector_new(sizeout);
4948 for (cpl_size i = 0 ; i < sizeout ; i++){
4949 cpl_vector_set(vector, i, cpl_vector_get(cpl_bivector_get_y(bivector_in), i+start));
4950 cpl_matrix_set(coord, 0, i, cpl_vector_get(cpl_bivector_get_x(bivector_in), i+start));
4955 cpl_polynomial * poly = cpl_polynomial_new(1);
4956 cpl_polynomial_fit (poly, coord, NULL, vector, NULL,
4957 CPL_FALSE, NULL, &power);
4959 sizeout=cpl_vector_get (cpl_bivector_get_y (bivector_in), size-1)-cpl_vector_get (cpl_bivector_get_y (bivector_in), 0);
4960 cpl_vector * vector_mean = cpl_vector_new (sizeout);
4962 cpl_vector_fill_polynomial (vector_mean, poly, 0, sizeout);
4963 double mean = cpl_vector_get_mean(vector_mean);
4965 cpl_vector_delete(vector_mean);
4966 cpl_vector_delete(vector);
4967 cpl_matrix_delete(coord);
4980 cpl_vector_sort(vector_in, CPL_SORT_ASCENDING);
4981 int size = cpl_vector_get_size(vector_in);
4982 int sizeout = size*(1-percent*2);
4983 int start = (size-sizeout)/2;
4984 cpl_vector * vector = cpl_vector_new(sizeout);
4986 for (cpl_size i = 0 ; i < sizeout ; i++)
4987 cpl_vector_set(vector, i, cpl_vector_get(vector_in, i+start));
4990 size = cpl_vector_get_size(vector);
4992 double med = cpl_vector_get_median(vector);
4993 double rms = cpl_vector_get_stdev(vector);
4996 for (cpl_size i = 0 ; i < size ; i++)
4997 if ( (cpl_vector_get(vector, i) > med-nsig*rms) && (cpl_vector_get(vector, i) < med+nsig*rms) ) sizeout++;
5000 cpl_vector * vector_med = cpl_vector_new(sizeout);
5001 for (cpl_size i = 0 ; i < size ; i++)
5002 if ( (cpl_vector_get(vector, i) > med-nsig*rms) && (cpl_vector_get(vector, i) < med+nsig*rms) )
5003 cpl_vector_set(vector_med, i_out++, cpl_vector_get(vector, i));
5005 return cpl_vector_get_mean(vector_med);
5011 const char * colname,
const char * sname)
5014 cpl_ensure_code (i_table);
5015 cpl_ensure_code (o_table);
5016 cpl_ensure_code (colname);
5019 if ( !cpl_table_has_column (i_table, colname)) {
5020 cpl_msg_info (cpl_func,
"Cannot average column %s (not in data)", colname);
5021 return CPL_ERROR_NONE;
5027 cpl_size nrow_i = cpl_table_get_nrow (output_o) /
ntel;
5028 int * first_i = cpl_table_get_data_int (output_o, sname);
5029 int * last_i = cpl_table_get_data_int (output_o, sname);
5030 cpl_ensure_code (first_i);
5031 cpl_ensure_code (last_i);
5033 const char * unit = cpl_table_get_column_unit (i_table, colname);
5036 double * i_data = cpl_table_get_data_double (i_table, colname);
5037 cpl_ensure_code (i_data);
5041 double * o_data = cpl_table_get_data_double (o_table, colname);
5044 for (cpl_size tel = 0; tel <
ntel; tel++) {
5045 for (cpl_size row_o = 0; row_o < nrow_o; row_o ++) {
5046 cpl_size no = row_o *
ntel + tel;
5049 for (cpl_size row_i = first_i[no] ; row_i < last_i[no]; row_i++) {
5050 cpl_size ni = row_i *
ntel + tel;
5051 o_data [no] += i_data[ni];
5053 CPLCHECK_MSG (
"Fail to compute metrology per base from metrology per tel");
5056 cpl_size nframe = last_met[nsc] - first_met[nsc];
5057 if (nframe != 0 ) o_data[no] /= nframe;
5062 return CPL_ERROR_NONE;
#define GRAVI_PRIMARY_HDR_EXT
typedefCPL_BEGIN_DECLS struct _gravi_data_ gravi_data
#define gravi_data_get_spectrum_data(data, type)
#define gravi_data_get_oi_flux(data, type, pol, npol)
#define gravi_data_get_header(data)
#define gravi_data_get_oi_wave(data, type, pol, npol)
#define gravi_data_get_oi_vis_plist(data, type, pol, npol)
#define gravi_data_get_imaging_detector(data, type)
#define gravi_data_get_oi_vis(data, type, pol, npol)
cpl_table * gravi_vis_create_opdguess_sc(cpl_table *spectrumsc_table, cpl_table *vis_FT, cpl_table *vis_MET, double dit_sc)
cpl_error_code gravi_lazer_get_wavelength(gravi_data *lazer_data)
int my_gsl_matrix_fprintf(FILE *stream, gsl_matrix *m, const char *fmt)
cpl_table * gravi_opdmet_calibration(cpl_table *metrology_table, double mjd_obs)
Compute the opd from metrology for the FC.
gravi_data_set_propertylist(wave_map, "WAVE_DATA_SC", plist)
cpl_table * gravi_wave_scan(cpl_table *spectrum_table, cpl_table *detector_table, cpl_table *opd_table)
cpl_error_code gravi_flux_create_average(cpl_table *i_table, cpl_table *o_table, const char *colname, const char *sname)
int gravi_get_basesign_from_tel(int t1, int t2)
gravi_data * gravi_compute_disp_old(gravi_data *vis_data)
cpl_error_code gravi_data_mean_metFddl(gravi_data *oi_vis, gravi_data *p2vmred_data, gravi_data *preproc_data, int thread)
Compute mean position of MET and FDDL in each DITs.
cpl_table * wavescan_table
static int finals2000A_mjd_last_type(FILE *pFile, char type)
cpl_table_save(vis_met, NULL, NULL, "vismet.fits", CPL_IO_CREATE)
gravi_data * gravi_visdata_fromellipse(gravi_data *spectrum_data)
cpl_error_code gravi_dtps(double xi, double eta, double raz, double decz, double *ra, double *dec)
cpl_table * gravi_metrology_reform(cpl_table *vis_met)
reform the PHASE_FC column of the metrology for the FC into OPD_FC
cpl_error_code gravi_p2vm_mean_spectrum(gravi_data *p2vm_map, gravi_data *preproc_data)
cpl_vector * gravi_phase_fit_opdmet(cpl_table *vis_met, cpl_table *phase_sc, cpl_table *phase_ft, double dit_sc)
cpl_table * gravi_metrology_calibration(cpl_table *metrology_table, cpl_table *opl_table, double mjd_obs)
The given output FITS file contain a p2vm table of the metrology with the values of the transmission,...
double gravi_bivector_get_med_poly(cpl_bivector *bivector_in)
double gravi_array_get_group_delay(cpl_array *input, cpl_array *sigma)
cpl_error_code gravi_compute_flat_badpix(gravi_data *flat, gravi_data *dark)
The aim of this function is to identify the bad pixels and to update profile accordingly.
static int finals2000A_mjd_first(FILE *pFile)
cpl_error_code gravi_data_save(gravi_data *self, cpl_frameset *allframes, const char *filename, const cpl_parameterlist *parlist, cpl_frameset *usedframes, cpl_frame *frame, const char *recipe, cpl_propertylist *applist)
static void finals2000A_read_line(FILE *pFile, char *flag, double *mjd, double *pmx, double *pmy, double *dut)
gravi_data_set_table(wave_map, "WAVE_DATA_SC", cpl_table_duplicate(wave_data_sc))
cpl_image_multiply(flat_profiled, profile_crop)
gravi_data_add_table(wave_map, NULL, type_data==GRAVI_SC ? "WAVE_SCAN_SC" :"WAVE_SCAN_FT", wavescan_table)
gravi_data_save_data(wave_data, "wave_map_argon.fits", CPL_IO_CREATE)
cpl_msg_debug(cpl_func, "Spectra has <50 pixels -> don't flat")
double gravi_envelope(double lambda, double delta_lambda, double opd)
gravi_data * gravi_eop_load_finals2000A(const char *eop_file)
cpl_image * flat_profiled
cpl_propertylist * header
int gravi_get_base_from_tel(int t1, int t2)
cpl_error_code gravi_phase_correct_closures(cpl_table *phase_table)
double gravi_array_get_group_delay_iota(cpl_array *input, cpl_array *wavenumber)
cpl_error_code gravi_normalize_flux(gravi_data *data)
gravi_data * gravi_fit_argon(gravi_data *argon_data, gravi_data *wave_data, gravi_data *profile_map, gravi_data *dark_map, gravi_data *bad_map)
This function calibrate the wavelength using the argon.
cpl_msg_info(cpl_func, "Compute WAVE_SCAN for %s", GRAVI_TYPE(type_data))
cpl_vector * gravi_construction_opd_phase(cpl_table *opl_table, cpl_table *phase_sc, cpl_table *phase_ft, double dit_sc)
double gravi_vector_get_med_percent(cpl_vector *vector_in, float percent)
int gravi_write_yorick_batch(const char *filename, const char *input_file, const char *output_file)
Create a yorick batch to execute mira on a OIFITS file.
cpl_error_code gravi_phase_correct_closures_new(cpl_table *phase_table)
double gravi_pfits_get_lambdamet(const cpl_propertylist *plist)
cpl_propertylist_update_double(header, "ESO QC MINWAVE SC", cpl_propertylist_get_double(plist, "ESO QC MINWAVE SC"))
gravi_data * gravi_compute_wave_offset(gravi_data *argon_wave, gravi_data *wave_data)
cpl_vector * gravi_image_to_vector(cpl_image *img)
int my_gsl_matrix_complex_fprintf(FILE *stream, gsl_matrix_complex *m, char *fmt)
double gravi_array_get_group_delay_coarse(cpl_array *input, cpl_array *sigma)
gravi_vis_create_phasesc_ft(phase_ft, phase_sc, dit_sc)
cpl_image_delete(flat_profiled)
cpl_error_code gravi_smooth_preproc(gravi_data *data, const cpl_parameterlist *parlist)
This function smooth the SC preproc data in the spectral direction in place, only for preproc (per re...
cpl_error_code gravi_array_get_group_delay_loop_new(cpl_array **input, cpl_array *sigma, double *gd, cpl_size nrow)
gravi_vis_create_met_ft(phase_ft, vis_met)
#define GRAVI_INSNAME(type, pol, npol)
#define GRAVI_OI_VIS_MET_EXT
#define GRAVI_IMAGING_DETECTOR_FT_EXT
#define GRAVI_WAVE_FIBRE_SC_EXT
#define GRAVI_PROFILE_DATA_EXT
#define GRAVI_WAVE_DATA_FT_EXT
#define GRAVI_WAVE_DATA_SC_EXT
#define GRAVI_EXTVER(type, pol, npol)
#define GRAVI_WAVE_ARGON_EXT
#define GRAVI_IMAGING_DATA_SC_EXT
#define GRAVI_SPECTRUM_DATA_FT_EXT
#define GRAVI_IMAGING_DETECTOR_SC_EXT
#define GRAVI_SPECTRUM_DATA_SC_EXT
#define CPLCHECK_INT(msg)
#define CPLCHECK_CLEAN(msg)
#define gravi_msg_function_exit(flag)
#define FREE(function, variable)
#define CPLCHECK_NUL(msg)
#define gravi_msg_function_start(flag)
#define CPLCHECK_MSG(msg)
#define FREELOOP(function, variable, n)
cpl_array * gravi_array_smooth(cpl_array *input_array, int DIT_smooth)
cpl_vector * gravi_vector_extract(const cpl_vector *vector, int start, int step)
Extract part of a vector.
cpl_error_code gravi_table_new_column(cpl_table *table, const char *name, const char *unit, cpl_type type)
cpl_error_code gravi_array_phase_unwrap(cpl_array *input)
double ** gravi_table_get_data_array_double(cpl_table *table, const char *name)
cpl_vector * gravi_table_get_vector(cpl_table *spectrum_data, cpl_size index, const char *regname)
Create a vector from the row index of the column regname.
cpl_error_code gravi_array_multiply_phasor(cpl_array *input, double complex factor, cpl_array *phase)
Multiply a REAL phase to a COMPLEX array, in-place: input = input * cexp (factor * phase)
cpl_size gravi_vector_get_maxpos(cpl_vector *vector)
Return the index of maximum in a vector. If several indexes exists with the maximum value,...
cpl_error_code gravi_table_new_column_array(cpl_table *table, const char *name, const char *unit, cpl_type type, cpl_size size)
cpl_propertylist * gravi_data_get_oi_plist(gravi_data *self, const char *extname, const char *insname)
Get the propertylist from EXTNAME and INSNAME.
cpl_error_code gravi_data_add_cube(gravi_data *self, cpl_propertylist *plist, const char *extname, cpl_imagelist *imglist)
Add an IMAGE (imagelist) extension in gravi_data.
cpl_propertylist * gravi_data_get_plist(gravi_data *self, const char *extname)
Get the propertylist from EXTNAME.
gravi_data * gravi_data_new(int nb_ext)
Create an empty gravi_data.
cpl_imagelist * gravi_data_get_cube(gravi_data *self, const char *extname)
Return a pointer on an IMAGE extension by its EXTNAME.
cpl_table * gravi_data_get_table(gravi_data *self, const char *extname)
Return a pointer on a table extension by its EXTNAME.
cpl_table * gravi_data_get_oi_table(gravi_data *self, const char *extname, const char *insname)
Get an OI_FITS table from EXTNAME and INSNAME.
cpl_propertylist * gravi_data_get_plist_x(gravi_data *self, int i)
Get the propertylist of an extension by position.
int gravi_data_get_size(const gravi_data *self)
Get the number of extension in a gravi_data.
void gravi_data_delete(gravi_data *self)
Delete a gravi data.
gravi_data * gravi_compute_disp(gravi_data *vis_data)
Compute the dispersion calibration map (DISP) FIXME: to be done.
static int sin_lambda(const double x[], const double a[], double *result)
Create the P2VM of the metrology.
static int dfda_sin(const double x[], const double a[], double result[])
int gravi_pfits_get_startx(const cpl_propertylist *plist)
find out the name of the propertylist
const char * gravi_pfits_get_insname(const cpl_propertylist *plist)
int gravi_pfits_get_pola_num(const cpl_propertylist *plist, int type_data)
int gravi_pfits_get_extension_type(const cpl_propertylist *plist)
const char * gravi_pfits_get_spec_res(const cpl_propertylist *plist)
const char * gravi_pfits_get_resolution(const cpl_propertylist *plist)
const char * gravi_pfits_get_extname(const cpl_propertylist *plist)
int gravi_pfits_get_window_start(const cpl_propertylist *plist)
gravi_data * gravi_extract_spectrum(gravi_data *raw_data, gravi_data *profile_map, gravi_data *dark_map, gravi_data *bad_map, gravi_data *sky_map, const cpl_parameterlist *parlist, enum gravi_detector_type det_type)
Create the SPECTRUM gravi_data with extracted spectrum per region.
cpl_error_code gravi_signal_create_sync(cpl_table *vis_SC, int nbase_sc, double dit_sc, cpl_table *vis_FT, int nbase_ft, const char *name)
Compute synchronisation indices between OIFITS tables.
int gravi_region_get_base(cpl_table *imaging_detector, int region)
Return the base of a region.
cpl_size gravi_spectrum_get_nwave(const cpl_table *table)
char GRAVI_DATAERR[50][10]
int GRAVI_TRI_SIGN[6][2][2]
int GRAVI_TRI_BASE[6][2][2]
cpl_size gravi_spectrum_get_nregion(const cpl_table *table)
cpl_vector * gravi_compute_envelope(const cpl_vector *opd, int wave, int nwave)
Compute the envelope value.
int gravi_get_region(cpl_table *img_det, int base, char phase, int pol)
Find the region matching base, phase and pol.
int gravi_region_get_base_sign(cpl_table *imaging_detector, int base)
Return the sign of a base by looking at the PORT order.
cpl_table * gravi_compute_argon_wave(cpl_table *spectrum_table)
Compute a WAVE calibration from the ARGON data (SC only)